@capgo/native-audio 8.2.12 → 8.2.14

package/ios/Sources/NativeAudioPlugin/AudioAsset.swift

@@ -1,76 +1,44 @@
-//
-//  AudioAsset.swift
-//  Plugin
-//
-//  Created by priyank on 2020-05-29.
-//  Copyright © 2022 Martin Donadieu. All rights reserved.
-//
-
 import AVFoundation
 
-/**
- * AudioAsset class handles local audio playback via AVAudioPlayer
- * Supports volume control, fade effects, rate changes, and looping
- */
+// swiftlint:disable:next type_body_length
 public class AudioAsset: NSObject, AVAudioPlayerDelegate {
 
     var channels: [AVAudioPlayer] = []
     var playIndex: Int = 0
     var assetId: String = ""
     var initialVolume: Float = 1.0
-    var fadeDelay: Float = 1.0
+    let zeroVolume: Float = 0.001
+    let maxVolume: Float = 1.0
     weak var owner: NativeAudio?
     var onComplete: (() -> Void)?
 
-    // Constants for fade effect
-    let FADESTEP: Float = 0.05
-    let FADEDELAY: Float = 0.08
-
-    // Maximum number of channels to prevent excessive resource usage
-    private let maxChannels = Constant.MaxChannels
-
-    // Timers - must only be accessed from main thread
+    let fadeDelaySecs: Float = 0.08
     private var currentTimeTimer: Timer?
     internal var fadeTimer: Timer?
+    var fadeTask: DispatchWorkItem?
+    let fadeQueue: DispatchQueue = DispatchQueue(label: "com.audioasset.fadeQueue")
+    var dispatchedCompleteMap: [String: Bool] = [:]
 
-    /**
-     * Initialize a new audio asset
-     * - Parameters:
-     *   - owner: The plugin that owns this asset
-     *   - assetId: Unique identifier for this asset
-     *   - path: File path to the audio file
-     *   - channels: Number of simultaneous playback channels (polyphony)
-     *   - volume: Initial volume (0.0-1.0)
-     *   - delay: Fade delay in seconds
-     */
-    init(owner: NativeAudio, withAssetId assetId: String, withPath path: String!, withChannels channels: Int!, withVolume volume: Float!, withFadeDelay delay: Float!) {
+    private var logger = Logger(logTag: "AudioAsset")
 
+    init(owner: NativeAudio, withAssetId assetId: String, withPath path: String, withChannels channels: Int?, withVolume volume: Float?) {
         self.owner = owner
         self.assetId = assetId
         self.channels = []
-        self.initialVolume = min(max(volume ?? Constant.DefaultVolume, Constant.MinVolume), Constant.MaxVolume) // Validate volume range
-        self.fadeDelay = max(delay ?? Constant.DefaultFadeDelay, 0.0) // Ensure non-negative delay
+        self.initialVolume = min(max(volume ?? Constant.DefaultVolume, Constant.MinVolume), Constant.MaxVolume)
 
         super.init()
 
         guard let encodedPath = path.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
-            print("Failed to encode path: \(String(describing: path))")
+            logger.error("Failed to encode path: %@", String(describing: path))
             return
         }
 
-        // Try to create URL from string first, fall back to file URL if that fails
-        let pathUrl: URL
-        if let url = URL(string: encodedPath) {
-            pathUrl = url
-        } else {
-            pathUrl = URL(fileURLWithPath: encodedPath)
-        }
-
-        // Limit channels to a reasonable maximum to prevent resource issues
-        let channelCount = min(max(channels ?? 1, 1), maxChannels)
+        let pathUrl = URL(string: encodedPath) ?? URL(fileURLWithPath: encodedPath)
+        let channelCount = min(max(channels ?? 1, 1), Constant.MaxChannels)
 
-        owner.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
+        let setupBlock = { [weak self] in
+            guard let self else { return }
             for _ in 0..<channelCount {
                 do {
                     let player = try AVAudioPlayer(contentsOf: pathUrl)
@@ -81,246 +49,170 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
                     player.prepareToPlay()
                     self.channels.append(player)
                 } catch {
-                    print("Error loading audio file: \(error.localizedDescription)")
-                    print("Path: \(String(describing: path))")
+                    self.logger.error("Error loading audio file: %@", error.localizedDescription)
                 }
             }
         }
+
+        if owner.isRunningTests {
+            setupBlock()
+        } else {
+            owner.executeOnAudioQueue(setupBlock)
+        }
     }
 
-    deinit {
-        // Invalidate timers - must be done on main thread
-        let currentTimer = currentTimeTimer
-        let fadeTimerRef = fadeTimer
+    // Backward-compatible initializer signature
+    init(owner: NativeAudio, withAssetId assetId: String, withPath path: String, withChannels channels: Int?, withVolume volume: Float?, withFadeDelay _: Float?) {
+        self.owner = owner
+        self.assetId = assetId
+        self.channels = []
+        self.initialVolume = min(max(volume ?? Constant.DefaultVolume, Constant.MinVolume), Constant.MaxVolume)
+        super.init()
 
-        if Thread.isMainThread {
-            currentTimer?.invalidate()
-            fadeTimerRef?.invalidate()
-        } else {
-            DispatchQueue.main.async {
-                currentTimer?.invalidate()
-                fadeTimerRef?.invalidate()
-            }
+        guard let encodedPath = path.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) else {
+            logger.error("Failed to encode path: %@", String(describing: path))
+            return
         }
 
-        // Clean up any players that might still be playing
-        for player in channels {
-            if player.isPlaying {
-                player.stop()
+        let pathUrl = URL(string: encodedPath) ?? URL(fileURLWithPath: encodedPath)
+        let channelCount = min(max(channels ?? 1, 1), Constant.MaxChannels)
+        let setupBlock = { [weak self] in
+            guard let self else { return }
+            for _ in 0..<channelCount {
+                do {
+                    let player = try AVAudioPlayer(contentsOf: pathUrl)
+                    player.delegate = self
+                    player.enableRate = true
+                    player.volume = self.initialVolume
+                    player.rate = 1.0
+                    player.prepareToPlay()
+                    self.channels.append(player)
+                } catch {
+                    self.logger.error("Error loading audio file: %@", error.localizedDescription)
+                }
             }
         }
+        if owner.isRunningTests {
+            setupBlock()
+        } else {
+            owner.executeOnAudioQueue(setupBlock)
+        }
+    }
+
+    deinit {
+        currentTimeTimer?.invalidate()
+        currentTimeTimer = nil
+        fadeTimer?.invalidate()
+        fadeTimer = nil
+        cancelFade()
+        for player in channels where player.isPlaying {
+            player.stop()
+        }
         channels = []
     }
 
-    /**
-     * Get the current playback time
-     * - Returns: Current time in seconds
-     */
     func getCurrentTime() -> TimeInterval {
         var result: TimeInterval = 0
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            if channels.isEmpty || playIndex >= channels.count {
-                result = 0
-                return
-            }
-            let player = channels[playIndex]
-            result = player.currentTime
+            guard let self else { return }
+            guard !channels.isEmpty, playIndex < channels.count else { return }
+            result = channels[playIndex].currentTime
         }
         return result
     }
 
-    /**
-     * Set the current playback time
-     * - Parameter time: Time in seconds
-     */
     func setCurrentTime(time: TimeInterval) {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            if channels.isEmpty || playIndex >= channels.count {
-                return
-            }
+            guard let self else { return }
+            guard !channels.isEmpty, playIndex < channels.count else { return }
             let player = channels[playIndex]
-            // Ensure time is valid
             let validTime = min(max(time, 0), player.duration)
             player.currentTime = validTime
         }
     }
 
-    /**
-     * Get the total duration of the audio file
-     * - Returns: Duration in seconds
-     */
     func getDuration() -> TimeInterval {
         var result: TimeInterval = 0
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            if channels.isEmpty || playIndex >= channels.count {
-                result = 0
-                return
-            }
-            let player = channels[playIndex]
-            result = player.duration
+            guard let self else { return }
+            guard !channels.isEmpty, playIndex < channels.count else { return }
+            result = channels[playIndex].duration
         }
         return result
     }
 
-    /**
-     * Play the audio from the specified time with optional delay
-     * - Parameters:
-     *   - time: Start time in seconds
-     *   - delay: Delay before playback in seconds
-     */
-    func play(time: TimeInterval, delay: TimeInterval) {
+    func play(time: TimeInterval, volume: Float? = nil) {
         stopCurrentTimeUpdates()
-        stopFadeTimer()
-
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
+            guard let self else { return }
             guard !channels.isEmpty else { return }
-
-            // Reset play index if it's out of bounds
             if playIndex >= channels.count {
                 playIndex = 0
             }
-
-            // Ensure the audio session is active before playing
             owner?.activateSession()
+            cancelFade()
 
             let player = channels[playIndex]
-            // Ensure time is within valid range
             let validTime = min(max(time, 0), player.duration)
             player.currentTime = validTime
             player.numberOfLoops = 0
-
-            // Use a valid delay (non-negative)
-            let validDelay = max(delay, 0)
-
-            if validDelay > 0 {
-                player.play(atTime: player.deviceCurrentTime + validDelay)
-            } else {
-                player.play()
-            }
+            player.volume = volume ?? initialVolume
+            player.play()
 
             playIndex = (playIndex + 1) % channels.count
             startCurrentTimeUpdates()
         }
     }
 
+    // Backward-compatible signature
+    func play(time: TimeInterval, delay: TimeInterval) {
+        let validDelay = max(delay, 0)
+        if validDelay > 0 {
+            DispatchQueue.main.asyncAfter(deadline: .now() + validDelay) { [weak self] in
+                self?.play(time: time, volume: nil)
+            }
+        } else {
+            play(time: time, volume: nil)
+        }
+    }
+
     func playWithFade(time: TimeInterval) {
-        owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
+        playWithFade(time: time, volume: nil, fadeInDuration: TimeInterval(Constant.DefaultFadeDuration))
+    }
 
+    func playWithFade(time: TimeInterval, volume: Float?, fadeInDuration: TimeInterval) {
+        owner?.executeOnAudioQueue { [weak self] in
+            guard let self else { return }
             guard !channels.isEmpty else { return }
-
-            // Reset play index if it's out of bounds
             if playIndex >= channels.count {
                 playIndex = 0
             }
 
             let player = channels[playIndex]
             player.currentTime = time
-
-            if !player.isPlaying {
-                player.numberOfLoops = 0
-                player.volume = 0 // Start with volume at 0
-                player.play()
-                playIndex = (playIndex + 1) % channels.count
-                startCurrentTimeUpdates()
-
-                // Start fade-in
-                startVolumeRamp(from: 0, to: initialVolume, player: player)
-            } else {
-                if player.volume < initialVolume {
-                    // Continue fade-in if already in progress
-                    startVolumeRamp(from: player.volume, to: initialVolume, player: player)
-                }
-            }
-        }
-    }
-
-    private func startVolumeRamp(from startVolume: Float, to endVolume: Float, player: AVAudioPlayer) {
-        stopFadeTimer()
-
-        let steps = abs(endVolume - startVolume) / FADESTEP
-        guard steps > 0 else { return }
-
-        let timeInterval = FADEDELAY / steps
-        var currentStep = 0
-        let totalSteps = Int(ceil(steps))
-
-        player.volume = startVolume
-
-        // Create timer on main thread
-        DispatchQueue.main.async { [weak self, weak player] in
-            guard let self = self else { return }
-
-            let timer = Timer.scheduledTimer(withTimeInterval: TimeInterval(timeInterval), repeats: true) { [weak self, weak player] timer in
-                guard let strongSelf = self, let strongPlayer = player else {
-                    timer.invalidate()
-                    return
-                }
-
-                currentStep += 1
-                let progress = Float(currentStep) / Float(totalSteps)
-                let newVolume = startVolume + progress * (endVolume - startVolume)
-
-                // Update player on audio queue
-                strongSelf.owner?.executeOnAudioQueue {
-                    strongPlayer.volume = newVolume
-                }
-
-                if currentStep >= totalSteps {
-                    strongSelf.owner?.executeOnAudioQueue {
-                        strongPlayer.volume = endVolume
-                    }
-                    timer.invalidate()
-                    strongSelf.fadeTimer = nil
-                }
-            }
-
-            self.fadeTimer = timer
-            RunLoop.current.add(timer, forMode: .common)
-        }
-    }
-
-    internal func stopFadeTimer() {
-        if Thread.isMainThread {
-            fadeTimer?.invalidate()
-            fadeTimer = nil
-        } else {
-            DispatchQueue.main.async { [weak self] in
-                self?.fadeTimer?.invalidate()
-                self?.fadeTimer = nil
-            }
+            player.numberOfLoops = 0
+            player.volume = 0
+            player.play()
+            playIndex = (playIndex + 1) % channels.count
+            startCurrentTimeUpdates()
+            fadeIn(audio: player, fadeInDuration: fadeInDuration, targetVolume: volume ?? initialVolume)
         }
     }
 
     func pause() {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
+            guard let self else { return }
+            guard !channels.isEmpty, playIndex < channels.count else { return }
+            cancelFade()
+            channels[playIndex].pause()
             stopCurrentTimeUpdates()
-
-            // Check for valid playIndex
-            guard !channels.isEmpty && playIndex < channels.count else { return }
-
-            let player = channels[playIndex]
-            player.pause()
         }
     }
 
     func resume() {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            // Check for valid playIndex
-            guard !channels.isEmpty && playIndex < channels.count else { return }
-
+            guard let self else { return }
+            guard !channels.isEmpty, playIndex < channels.count else { return }
             let player = channels[playIndex]
             let timeOffset = player.deviceCurrentTime + 0.01
             player.play(atTime: timeOffset)
@@ -330,11 +222,9 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
 
     func stop() {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
+            guard let self else { return }
+            cancelFade()
             stopCurrentTimeUpdates()
-            stopFadeTimer()
-
             for player in channels {
                 if player.isPlaying {
                     player.stop()
@@ -343,32 +233,25 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
                 player.numberOfLoops = 0
             }
             playIndex = 0
+            dispatchComplete()
         }
     }
 
     func stopWithFade() {
-        // Store current player locally to avoid race conditions with playIndex
-        owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
+        stopWithFade(fadeOutDuration: TimeInterval(Constant.DefaultFadeDuration), toPause: false)
+    }
 
-            guard !channels.isEmpty && playIndex < channels.count else {
-                stop()
+    func stopWithFade(fadeOutDuration: TimeInterval, toPause: Bool = false) {
+        owner?.executeOnAudioQueue { [weak self] in
+            guard let self else { return }
+            guard !channels.isEmpty, playIndex < channels.count else {
+                if !toPause { stop() }
                 return
             }
-
             let player = channels[playIndex]
             if player.isPlaying && player.volume > 0 {
-                startVolumeRamp(from: player.volume, to: 0, player: player)
-
-                // Schedule the stop when fade is complete
-                DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(Int(FADEDELAY * 1000))) { [weak self, weak player] in
-                    guard let strongSelf = self, let strongPlayer = player else { return }
-
-                    if strongPlayer.volume < strongSelf.FADESTEP {
-                        strongSelf.stop()
-                    }
-                }
-            } else {
+                fadeOut(audio: player, fadeOutDuration: fadeOutDuration, toPause: toPause)
+            } else if !toPause {
                 stop()
             }
         }
@@ -376,12 +259,10 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
 
     func loop() {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            self.stop()
-
-            guard !channels.isEmpty && playIndex < channels.count else { return }
-
+            guard let self else { return }
+            cancelFade()
+            stop()
+            guard !channels.isEmpty, playIndex < channels.count else { return }
             let player = channels[playIndex]
             player.delegate = self
             player.numberOfLoops = -1
@@ -393,39 +274,36 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
 
     func unload() {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            self.stop()
+            guard let self else { return }
+            cancelFade()
+            stop()
             stopCurrentTimeUpdates()
-            stopFadeTimer()
             channels = []
         }
     }
 
-    /**
-     * Set the volume for all audio channels
-     * - Parameter volume: Volume level (0.0-1.0)
-     */
-    func setVolume(volume: NSNumber!) {
-        owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
+    func setVolume(volume: NSNumber) {
+        setVolume(volume: volume, fadeDuration: 0)
+    }
 
-            // Ensure volume is in valid range
+    func setVolume(volume: NSNumber, fadeDuration: Double) {
+        owner?.executeOnAudioQueue { [weak self] in
+            guard let self else { return }
+            cancelFade()
             let validVolume = min(max(volume.floatValue, Constant.MinVolume), Constant.MaxVolume)
             for player in channels {
-                player.volume = validVolume
+                if player.isPlaying && fadeDuration > 0 {
+                    fadeTo(audio: player, fadeDuration: fadeDuration, targetVolume: validVolume)
+                } else {
+                    player.volume = validVolume
+                }
             }
         }
     }
 
-    /// Sets the playback rate for every channel, clamping the provided value to the allowed range before applying it.
-    /// - Parameters:
-    ///   - rate: Playback rate multiplier; the value is clamped to the asset's allowed rate range and applied to all channels.
-    func setRate(rate: NSNumber!) {
+    func setRate(rate: NSNumber) {
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            // Ensure rate is in valid range
+            guard let self else { return }
             let validRate = min(max(rate.floatValue, Constant.MinRate), Constant.MaxRate)
             for player in channels {
                 player.rate = validRate
@@ -433,92 +311,58 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
         }
     }
 
-    /// Handles an AVAudioPlayer finishing playback by notifying listeners, invoking the public completion callback, and forwarding the completion to the owner.
-    ///
-    /// This is called when a player finishes playing; the notifications and callback are dispatched on the audio queue. Notifications are sent to listeners with the asset's `assetId`, then `onComplete` is invoked if set, and finally the event is forwarded to the owner.
-    /// - Parameters:
-    ///   - player: The `AVAudioPlayer` instance that finished playback.
-    /// Handle an AVAudioPlayer finishing playback by notifying listeners, invoking the optional `onComplete` callback, and forwarding the completion to the owner.
-    /// - Note: The handler's work is dispatched on the audio queue.
-    /// - Parameters:
-    ///   - player: The `AVAudioPlayer` instance that finished playback.
-    ///   - flag: `true` if playback finished successfully, `false` otherwise.
-    public func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+    func isPlaying() -> Bool {
+        var result = false
         owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            self.owner?.notifyListeners("complete", data: [
-                "assetId": self.assetId
-            ])
-
-            // Invoke completion callback if set
-            self.onComplete?()
-
-            // Notify the owner that this player finished
-            // The owner will check if any other assets are still playing
-            owner?.audioPlayerDidFinishPlaying(player, successfully: flag)
+            guard let self else { return }
+            result = channels.contains(where: { $0.isPlaying })
         }
+        return result
     }
 
-    func playerDecodeError(player: AVAudioPlayer!, error: NSError!) {
-        if let error = error {
-            print("AudioAsset decode error: \(error.localizedDescription)")
+    public func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+        owner?.executeOnAudioQueue { [weak self] in
+            guard let self else { return }
+            dispatchComplete()
+            onComplete?()
+            owner?.audioPlayerDidFinishPlaying(player, successfully: flag)
         }
     }
 
-    func isPlaying() -> Bool {
-        var result: Bool = false
-        owner?.executeOnAudioQueue { [weak self] in
-            guard let self = self else { return }
-
-            if channels.isEmpty || playIndex >= channels.count {
-                result = false
-                return
-            }
-            let player = channels[playIndex]
-            result = player.isPlaying
+    func playerDecodeError(player: AVAudioPlayer, error: NSError?) {
+        if let error {
+            logger.error("AudioAsset decode error: %@", error.localizedDescription)
         }
-        return result
     }
 
     internal func startCurrentTimeUpdates() {
+        stopCurrentTimeUpdates()
+        dispatchedCompleteMap[assetId] = false
         DispatchQueue.main.async { [weak self] in
-            guard let strongSelf = self else { return }
-
-            // Stop existing timer first (we're on main thread now)
-            strongSelf.currentTimeTimer?.invalidate()
-            strongSelf.currentTimeTimer = nil
-
-            let timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
-                guard let strongSelf = self, let strongOwner = strongSelf.owner else {
+            guard let self else { return }
+            let timer = Timer(timeInterval: 0.1, repeats: true) { [weak self] _ in
+                guard let self, let owner else {
                     self?.stopCurrentTimeUpdates()
                     return
                 }
-
-                if strongSelf.isPlaying() {
-                    strongOwner.notifyCurrentTime(strongSelf)
+                if self.isPlaying() {
+                    owner.notifyCurrentTime(self)
                 } else {
-                    strongSelf.stopCurrentTimeUpdates()
+                    self.stopCurrentTimeUpdates()
                 }
             }
-
-            strongSelf.currentTimeTimer = timer
+            self.currentTimeTimer = timer
             RunLoop.current.add(timer, forMode: .common)
         }
     }
 
-    /// Stops and clears the periodic current-time update timer, ensuring invalidation occurs on the main thread.
-    ///
-    /// This method is safe to call from any thread; if not currently on the main thread the invalidation is dispatched to the main queue.
     internal func stopCurrentTimeUpdates() {
-        if Thread.isMainThread {
-            currentTimeTimer?.invalidate()
-            currentTimeTimer = nil
-        } else {
-            DispatchQueue.main.async { [weak self] in
-                self?.currentTimeTimer?.invalidate()
-                self?.currentTimeTimer = nil
-            }
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            logger.debug("Stop current time updates")
+            self.currentTimeTimer?.invalidate()
+            self.currentTimeTimer = nil
         }
     }
+
 }