@javascriptcommon/react-native-track-player 4.1.26 → 4.1.28

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/AudioPlayer.kt

@@ -234,6 +234,10 @@ abstract class AudioPlayer internal constructor(
             .setContentType(options.audioContentType)
             .build()
         mPlayer.setAudioAttributes(audioAttributes, options.handleAudioFocus)
+        // Prevent ExoPlayer from auto-advancing to the next queue item when a track ends.
+        // All track transitions are handled by the JS side via playNext() -> load().
+        // This avoids ExoPlayer trying to load queue items that don't have a URL yet.
+        mPlayer.pauseAtEndOfMediaItems = true
         nameHolder[0] = mPlayer.toString()
         // https://github.com/androidx/media/issues/2319
         mPlayer.addAnalyticsListener(AudioFxInitListener())

package/ios/Example/SwiftAudio/AudioController.swift

@@ -26,7 +26,7 @@ class AudioController {
     
     init() {
         let controller = RemoteCommandController()
-        player = QueuedAudioPlayer(remoteCommandController: controller)
+        player = QueuedAudioPlayer(remoteCommandController: controller, crossfade: true)
         player.remoteCommands = [
             .stop,
             .play,
@@ -36,7 +36,7 @@ class AudioController {
             .previous,
             .changePlaybackPosition
         ]
-        player.audioTap = WaveformAudioTap()
+        // player.audioTap = WaveformAudioTap()
         player.repeatMode = .queue
         DispatchQueue.main.async {
             self.player.add(items: self.sources)

package/ios/Example/SwiftAudio/PlayerView.swift

@@ -106,8 +106,25 @@ struct PlayerView: View {
                 })
                 .frame(maxWidth: .infinity)
             }
-            .padding(.top, 80)
+            .padding(.top, 20)
 
+            HStack {
+                Button(action: { controller.player.crossfadePrepare() }, label: {
+                    Text("Crossfade Prepare")
+                        .font(.system(size: 14))
+                })
+                .frame(maxWidth: .infinity)
+
+                .frame(maxWidth: .infinity)
+                Button(action: { controller.player.switchExoPlayer() }, label: {
+                    Text("Crossfade Switch")
+                        .font(.system(size: 14))
+                })
+                .frame(maxWidth: .infinity)
+            }
+            .padding(.top, 20)
+
+            
             VStack {
                 if viewModel.playbackState == .failed {
                     Text("Playback failed.")

package/ios/RNTrackPlayer/RNTrackPlayer.swift

@@ -33,7 +33,7 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
     @objc public weak var delegate: RNTPDelegate? = nil
     // MARK: - Attributes
     private var hasInitialized = false
-    private let player = QueuedAudioPlayer()
+    private let player = QueuedAudioPlayer(crossfade: true)
     private let audioSessionController = AudioSessionController.shared
     private let equalizerTap = EqualizerAudioTap()  // Always created, attached at setup
     private var shouldEmitProgressEvent: Bool = false
@@ -1067,6 +1067,22 @@ public class RNTrackPlayer: NSObject, AudioSessionControllerDelegate {
         equalizerTap.balance = max(-1, min(1, balance))
         resolve(NSNull())
     }
+
+    // MARK: - Crossfade
+
+    @objc(crossFadePrepare:seekTo:resolver:rejecter:)
+    public func crossFadePrepare(previous: Bool, seekTo: NSNumber, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        player.crossfadePrepare(previous: previous)
+        resolve(NSNull())
+    }
+
+    @objc(switchExoPlayer:fadeInterval:fadeToVolume:waitUntil:resolver:rejecter:)
+    public func switchExoPlayer(fadeDuration: Double, fadeInterval: Double, fadeToVolume: Double, waitUntil: NSNumber, resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        if (rejectWhenNotInitialized(reject: reject)) { return }
+        player.switchExoPlayer(fadeDuration: Int(fadeDuration), fadeInterval: Int(fadeInterval), fadeToVolume: Float(fadeToVolume))
+        resolve(NSNull())
+    }
 }
 
 extension RNTrackPlayer {

package/ios/RNTrackPlayer/TrackPlayer.mm

@@ -205,6 +205,7 @@ RCT_EXPORT_MODULE()
 }
 
 - (void)crossFadePrepare:(BOOL)previous seekTo:(nonnull NSNumber *)seekTo resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer crossFadePrepare:previous seekTo:seekTo resolver:resolve rejecter:reject];
 }
 
 - (void)fadeOutJump:(double)index duration:(double)duration interval:(double)interval toVolume:(double)toVolume resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
@@ -244,6 +245,7 @@ RCT_EXPORT_MODULE()
 }
 
 - (void)switchExoPlayer:(double)fadeDuration fadeInterval:(double)fadeInterval fadeToVolume:(double)fadeToVolume waitUntil:(nonnull NSNumber *)waitUntil resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+    [trackPlayer switchExoPlayer:fadeDuration fadeInterval:fadeInterval fadeToVolume:fadeToVolume waitUntil:waitUntil resolver:resolve rejecter:reject];
 }
 
 // iOS Equalizer methods

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/AudioPlayer.swift

@@ -12,8 +12,24 @@ public typealias AudioPlayerState = AVPlayerWrapperState
 
 public class AudioPlayer: AVPlayerWrapperDelegate {
     /// The wrapper around the underlying AVPlayer
-    let wrapper: AVPlayerWrapperProtocol = AVPlayerWrapper()
-
+    let wrapper1: AVPlayerWrapperProtocol = AVPlayerWrapper()
+    var wrapper2: AVPlayerWrapperProtocol? = nil
+    // this is the current wrapper
+    var wrapper: AVPlayerWrapperProtocol
+    // this is the secondary/crossfade wrapper
+    var crossfadeWrapper: AVPlayerWrapperProtocol
+    // when true, the current wrapper is wrapper1; else, wrapper2
+    // for crossfade tracking
+    var currentAVPlayer = true
+    // indicates if crossfade is enabled/wrapper2 is initialized
+    var crossfade: Bool = false
+
+    func players () -> [AVPlayerWrapperProtocol] {
+        if (self.crossfade) {
+            return [wrapper1, wrapper2!]
+        }
+        return [wrapper1]
+    }
     
     /**
      Set an instance of AudioTap, to receive frame information and audio buffer access during playback.
@@ -29,6 +45,9 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
     public let event = EventHolder()
 
     private(set) var currentItem: AudioItem?
+    // as audioplayer does NOT hold queue information, the crossfading audioItem needs to be
+    // stored as such - whereas exoplayer has a built in queue and can just skipToIndex
+    var crossfadeItem: AudioItem?
 
     /**
      Set this to false to disable automatic updating of now playing info for control center and lock screen.
@@ -190,10 +209,19 @@ public class AudioPlayer: AVPlayerWrapperDelegate {
      - parameter infoCenter: The InfoCenter to update. Default is `MPNowPlayingInfoCenter.default()`.
      */
     public init(nowPlayingInfoController: NowPlayingInfoControllerProtocol = NowPlayingInfoController(),
-                remoteCommandController: RemoteCommandController = RemoteCommandController()) {
+                remoteCommandController: RemoteCommandController = RemoteCommandController(),
+                crossfade: Bool = false
+    ) {
         self.nowPlayingInfoController = nowPlayingInfoController
         self.remoteCommandController = remoteCommandController
-
+        self.wrapper = self.wrapper1
+        self.crossfade = crossfade
+        if (crossfade) {
+            self.wrapper2 = AVPlayerWrapper()
+            self.crossfadeWrapper = self.wrapper2!
+        } else {
+            self.crossfadeWrapper = self.wrapper
+        }
         wrapper.delegate = self
         self.remoteCommandController.audioPlayer = self
     }

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/QueueManager.swift

@@ -37,7 +37,7 @@ class QueueManager<Element> {
     /**
      The index of the current item. `-1` when there is no current item
      */
-    private(set) var currentIndex: Int {
+    var currentIndex: Int {
         get {
             return synchronize {
                 return _currentIndex
@@ -352,5 +352,17 @@ class QueueManager<Element> {
             delegate?.onCurrentItemChanged()
         }
     }
-
+ 
+    // peek for the next item. does not change currentIndex
+    public func peek(direction: Int = 1) -> Int {
+        if (items.isEmpty) {
+            return -1
+        }
+        var finalIndex = (currentIndex + direction) % items.count
+        if (finalIndex < 0) {
+            finalIndex += items.count
+        }
+        return finalIndex
+    }
+    
 }

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/QueuedAudioPlayer.swift

@@ -15,9 +15,107 @@ public class QueuedAudioPlayer: AudioPlayer, QueueManagerDelegate {
     let queue: QueueManager = QueueManager<AudioItem>()
     fileprivate var lastIndex: Int = -1
     fileprivate var lastItem: AudioItem? = nil
+    
+    func findOrInsert(item: AudioItem) -> Int {
+        var itemIndex = queue.items.firstIndex(where: {$0.getSourceUrl() == item.getSourceUrl()})
+        if (itemIndex == nil) {
+            add(item: item)
+            itemIndex = queue.items.count - 1
+        }
+        queue.currentIndex = itemIndex!
+        return itemIndex!
+    }
+
+    public func crossfadePrepare(item: AudioItem) {
+        if (!self.crossfade) {
+            return
+        }
+        self.crossfadeWrapper.load(
+            from: item.getSourceUrl(),
+            type: item.getSourceType(),
+            playWhenReady: false,
+            initialTime: (item as? InitialTiming)?.getInitialTime(),
+            options:(item as? AssetOptionsProviding)?.getAssetOptions()
+        )
+        self.crossfadeItem = item
+    }
+    
+    public func crossfadePrepare(previous: Bool = false) {
+        let nextIndex = queue.peek(direction: previous ? -1 : 1)
+        if (nextIndex < 0) {
+            // TODO: should throw error instead
+            return
+        }
+        self.crossfadePrepare(item: queue.items[nextIndex])
+    }
+    
+    public func switchExoPlayer(
+        fadeDuration: Int = 2500,
+        fadeInterval: Int = 20,
+        fadeToVolume: Float = 1
+    ) {
+        if (!self.crossfade || self.crossfadeItem == nil) {
+            return
+        }
+        if (self.currentAVPlayer) {
+            self.crossfadeWrapper = self.wrapper1
+            self.wrapper = self.wrapper2!
+        } else {
+            self.crossfadeWrapper = self.wrapper2!
+            self.wrapper = self.wrapper1
+        }
 
-    public override init(nowPlayingInfoController: NowPlayingInfoControllerProtocol = NowPlayingInfoController(), remoteCommandController: RemoteCommandController = RemoteCommandController()) {
-        super.init(nowPlayingInfoController: nowPlayingInfoController, remoteCommandController: remoteCommandController)
+        // switch the event emittting delegate
+        self.wrapper.delegate = self
+        self.crossfadeWrapper.delegate = nil
+
+        // broadcast nowplaying to system
+        self.findOrInsert(item: self.crossfadeItem!)
+        loadNowPlayingMetaValues()
+        emitCurrentItemEvent()
+
+        self.crossfadeItem = nil
+        self.currentAVPlayer = !self.currentAVPlayer
+
+        // fade volume
+        Task {
+            var fadeOutDuration = fadeDuration
+            let startFadeOutTime = DispatchTime.now()
+            let fadeFromVolume = self.crossfadeWrapper.volume
+            while (fadeOutDuration > 0) {
+                fadeOutDuration -= fadeInterval
+                let timeDiff = DispatchTime.now().uptimeNanoseconds - startFadeOutTime.uptimeNanoseconds
+                let timeElapsed = Float(min(Int(timeDiff) / 1_000_000, fadeDuration))
+                self.crossfadeWrapper.volume = fadeFromVolume * (1 -  timeElapsed / Float(fadeDuration))
+                print("crossfade fading out...\(self.crossfadeWrapper.volume)")
+                try await Task.sleep(nanoseconds: UInt64(fadeInterval * 1000000))
+            }
+        }
+        
+        Task {
+            self.wrapper.volume = 0
+            if (fadeToVolume > 0) {
+                self.wrapper.play()
+                var fadeInDuration = fadeDuration
+                let startTime = DispatchTime.now()
+                while (fadeInDuration > 0) {
+                    fadeInDuration -= fadeInterval
+                    let timeDiff = DispatchTime.now().uptimeNanoseconds - startTime.uptimeNanoseconds
+                    let timeElapsed = Float(min(Int(timeDiff) / 1_000_000, fadeDuration))
+                    self.wrapper.volume = fadeToVolume * timeElapsed / Float(fadeDuration)
+                    print("crossfade fading in...\(self.wrapper.volume)")
+                    try await Task.sleep(nanoseconds: UInt64(fadeInterval * 1000000))
+                }
+            }
+        }
+    }
+    
+    public override init(
+        nowPlayingInfoController: NowPlayingInfoControllerProtocol = NowPlayingInfoController(),
+        remoteCommandController: RemoteCommandController = RemoteCommandController(),
+        crossfade: Bool = false
+    ) {
+        super.init(nowPlayingInfoController: nowPlayingInfoController, remoteCommandController: remoteCommandController, crossfade: crossfade)
         queue.delegate = self
     }
 
@@ -224,6 +322,8 @@ public class QueuedAudioPlayer: AudioPlayer, QueueManagerDelegate {
         } else {
             super.clear()
         }
+    func emitCurrentItemEvent(lastPosition: Double = 0) {
+        let currentItem = currentItem
         event.currentItem.emit(
             data: (
                 item: currentItem,
@@ -248,6 +348,16 @@ public class QueuedAudioPlayer: AudioPlayer, QueueManagerDelegate {
             }
         }
         return false
+    // MARK: - QueueManagerDelegate
+
+    func onCurrentItemChanged() {
+        let lastPosition = currentTime;
+        if let currentItem = currentItem {
+            super.load(item: currentItem)
+        } else {
+            super.clear()
+        }
+        emitCurrentItemEvent(lastPosition: lastPosition)
     }
 
     func onSkippedToSameCurrentItem() {

package/lib/src/trackPlayer.js

@@ -573,8 +573,6 @@ export async function abandonWakeLock() {
  * crossfade so the resource can be prepared.
  */
 export async function crossFadePrepare(previous = false, seekTo = 0) {
-    if (!isAndroid)
-        return;
     TrackPlayer.crossFadePrepare(previous, seekTo);
 }
 /**
@@ -587,8 +585,6 @@ export async function crossFadePrepare(previous = false, seekTo = 0) {
  * waitUntil is in ms.
  */
 export async function crossFade(fadeDuration = 2000, fadeInterval = 20, fadeToVolume = 1, waitUntil = 0) {
-    if (!isAndroid)
-        return;
     TrackPlayer.switchExoPlayer(fadeDuration, fadeInterval, fadeToVolume, waitUntil);
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "4.1.26",
+  "version": "4.1.28",
   "description": "A fully fledged audio module created for music apps",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

package/src/trackPlayer.ts

@@ -747,7 +747,6 @@ export async function abandonWakeLock() {
  * crossfade so the resource can be prepared.
  */
 export async function crossFadePrepare(previous = false, seekTo = 0) {
-  if (!isAndroid) return;
   TrackPlayer.crossFadePrepare(previous, seekTo);
 }
 
@@ -766,7 +765,6 @@ export async function crossFade(
   fadeToVolume = 1,
   waitUntil = 0,
 ) {
-  if (!isAndroid) return;
   TrackPlayer.switchExoPlayer(
     fadeDuration,
     fadeInterval,