@capgo/native-audio 7.1.7 → 7.3.0

package/ios/Plugin/AudioAsset.swift

@@ -20,70 +20,88 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
     let FADESTEP: Float = 0.05
     let FADEDELAY: Float = 0.08
 
+    private var currentTimeTimer: Timer?
+
     init(owner: NativeAudio, withAssetId assetId: String, withPath path: String!, withChannels channels: Int!, withVolume volume: Float!, withFadeDelay delay: Float!) {
 
         self.owner = owner
         self.assetId = assetId
         self.channels = []
+        self.initialVolume = volume ?? 1.0
 
         super.init()
 
         let pathUrl: URL = URL(string: path.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!)!
-        for _ in 0..<channels {
-            do {
-                let player: AVAudioPlayer! = try AVAudioPlayer(contentsOf: pathUrl)
-                player.delegate = owner
-
-                if player != nil {
-                    player.enableRate = true
-                    player.volume = volume
-                    player.prepareToPlay()
-                    self.channels.append(player)
-                    if channels == 1 {
-                        player.delegate = self
+
+        owner.executeOnAudioQueue { [self] in
+            for _ in 0..<channels {
+                do {
+                    let player: AVAudioPlayer! = try AVAudioPlayer(contentsOf: pathUrl)
+                    player.delegate = self
+                    if player != nil {
+                        player.enableRate = true
+                        player.volume = volume
+                        player.rate = 1.0
+                        player.prepareToPlay()
+                        self.channels.append(player)
                     }
+                } catch let error as NSError {
+                    print(error.debugDescription)
+                    print("Error loading \(String(describing: path))")
                 }
-            } catch let error as NSError {
-                print(error.debugDescription)
-                print("Error loading \(String(describing: path))")
             }
         }
     }
 
     func getCurrentTime() -> TimeInterval {
-        if channels.count != 1 {
-            return 0
+        var result: TimeInterval = 0
+        owner.executeOnAudioQueue { [self] in
+            if channels.count != 1 {
+                result = 0
+                return
+            }
+            let player: AVAudioPlayer = channels[playIndex]
+            result = player.currentTime
         }
-        let player: AVAudioPlayer = channels[playIndex]
-
-        return player.currentTime
+        return result
     }
 
     func setCurrentTime(time: TimeInterval) {
-        if channels.count != 1 {
-            return
+        owner.executeOnAudioQueue { [self] in
+            if channels.count != 1 {
+                return
+            }
+            let player: AVAudioPlayer = channels[playIndex]
+            player.currentTime = time
         }
-
-        let player: AVAudioPlayer = channels[playIndex]
-
-        player.currentTime = time
     }
 
     func getDuration() -> TimeInterval {
-        if channels.count != 1 {
-            return 0
+        var result: TimeInterval = 0
+        owner.executeOnAudioQueue { [self] in
+            if channels.count != 1 {
+                result = 0
+                return
+            }
+            let player: AVAudioPlayer = channels[playIndex]
+            result = player.duration
         }
-
-        let player: AVAudioPlayer = channels[playIndex]
-
-        return player.duration
+        return result
     }
 
     func play(time: TimeInterval, delay: TimeInterval) {
-        let player: AVAudioPlayer
+        owner.executeOnAudioQueue { [self] in
+            guard !channels.isEmpty else {
+                NSLog("No channels available")
+                return
+            }
+            guard playIndex < channels.count else {
+                NSLog("PlayIndex out of bounds")
+                playIndex = 0
+                return
+            }
 
-        if channels.count > 0 {
-            player = channels[playIndex]
+            let player = channels[playIndex]
             player.currentTime = time
             player.numberOfLoops = 0
             if delay > 0 {
@@ -93,100 +111,137 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
             }
             playIndex += 1
             playIndex = playIndex % channels.count
+            NSLog("About to start timer updates")
+            startCurrentTimeUpdates()
         }
     }
 
     func playWithFade(time: TimeInterval) {
-        let player: AVAudioPlayer = channels[playIndex]
-        player.currentTime = time
+        owner.executeOnAudioQueue { [self] in
+            guard !channels.isEmpty else {
+                NSLog("No channels available")
+                return
+            }
+            guard playIndex < channels.count else {
+                NSLog("PlayIndex out of bounds")
+                playIndex = 0
+                return
+            }
 
-        if !player.isPlaying {
-            player.numberOfLoops = 0
-            player.volume = 0
-            player.play()
-            playIndex += 1
-            playIndex = playIndex % channels.count
-        } else {
-            if player.volume < initialVolume {
-                player.volume += self.FADESTEP
+            let player: AVAudioPlayer = channels[playIndex]
+            player.currentTime = time
+
+            if !player.isPlaying {
+                player.numberOfLoops = 0
+                player.volume = initialVolume
+                player.play()
+                playIndex += 1
+                playIndex = playIndex % channels.count
+                NSLog("PlayWithFade: About to start timer updates")
+                startCurrentTimeUpdates()
+            } else {
+                if player.volume < initialVolume {
+                    player.volume += self.FADESTEP
+                }
             }
         }
-
     }
 
     func pause() {
-        let player: AVAudioPlayer = channels[playIndex]
-        player.pause()
+        owner.executeOnAudioQueue { [self] in
+            stopCurrentTimeUpdates()
+            let player: AVAudioPlayer = channels[playIndex]
+            player.pause()
+        }
     }
 
     func resume() {
-        let player: AVAudioPlayer = channels[playIndex]
-
-        let timeOffset = player.deviceCurrentTime + 0.01
-        player.play(atTime: timeOffset)
+        owner.executeOnAudioQueue { [self] in
+            let player: AVAudioPlayer = channels[playIndex]
+            let timeOffset = player.deviceCurrentTime + 0.01
+            player.play(atTime: timeOffset)
+            NSLog("Resume: About to start timer updates")
+            startCurrentTimeUpdates()
+        }
     }
 
     func stop() {
-        for player in channels {
-            player.stop()
+        owner.executeOnAudioQueue { [self] in
+            stopCurrentTimeUpdates()
+            for player in channels {
+                if player.isPlaying {
+                    player.stop()
+                }
+                player.currentTime = 0
+                player.numberOfLoops = 0
+            }
+            playIndex = 0
         }
     }
 
     func stopWithFade() {
-        let player: AVAudioPlayer = channels[playIndex]
-
-        if !player.isPlaying {
-            player.currentTime = 0.0
-            player.numberOfLoops = 0
-            player.volume = 0
-            player.play()
-            playIndex += 1
-            playIndex = playIndex % channels.count
-        } else {
-            if player.volume < initialVolume {
-                player.volume += self.FADESTEP
+        owner.executeOnAudioQueue { [self] in
+            let player: AVAudioPlayer = channels[playIndex]
+            if player.isPlaying {
+                if player.volume > self.FADESTEP {
+                    player.volume -= self.FADESTEP
+                    // Schedule next fade step
+                    DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(Int(self.FADEDELAY * 1000))) { [weak self] in
+                        self?.stopWithFade()
+                    }
+                } else {
+                    // Volume is near 0, actually stop
+                    player.volume = 0
+                    self.stop()
+                }
             }
         }
     }
 
     func loop() {
-        self.stop()
-
-        let player: AVAudioPlayer = channels[playIndex]
-        player.numberOfLoops = -1
-        player.play()
-        playIndex += 1
-        playIndex = playIndex % channels.count
+        owner.executeOnAudioQueue { [self] in
+            self.stop()
+            let player: AVAudioPlayer = channels[playIndex]
+            player.delegate = self
+            player.numberOfLoops = -1
+            player.play()
+            playIndex += 1
+            playIndex = playIndex % channels.count
+            NSLog("Loop: About to start timer updates")
+            startCurrentTimeUpdates()
+        }
     }
 
     func unload() {
-        self.stop()
-
-        //        for i in 0..<channels.count {
-        //            var player: AVAudioPlayer! = channels.object(at: i) as? AVAudioPlayer
-        //
-        //            player = nil
-        //        }
-        channels = []
+        owner.executeOnAudioQueue { [self] in
+            self.stop()
+            channels = []
+        }
     }
 
     func setVolume(volume: NSNumber!) {
-        for player in channels {
-            player.volume = volume.floatValue
+        owner.executeOnAudioQueue { [self] in
+            for player in channels {
+                player.volume = volume.floatValue
+            }
         }
     }
 
     func setRate(rate: NSNumber!) {
-        for player in channels {
-            player.rate = rate.floatValue
+        owner.executeOnAudioQueue { [self] in
+            for player in channels {
+                player.rate = rate.floatValue
+            }
         }
     }
 
     public func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
-        NSLog("playerDidFinish")
-        self.owner.notifyListeners("complete", data: [
-            "assetId": self.assetId
-        ])
+        owner.executeOnAudioQueue { [self] in
+            NSLog("playerDidFinish")
+            self.owner.notifyListeners("complete", data: [
+                "assetId": self.assetId
+            ])
+        }
     }
 
     func playerDecodeError(player: AVAudioPlayer!, error: NSError!) {
@@ -194,11 +249,62 @@ public class AudioAsset: NSObject, AVAudioPlayerDelegate {
     }
 
     func isPlaying() -> Bool {
-        if channels.count != 1 {
-            return false
+        var result: Bool = false
+        owner.executeOnAudioQueue { [self] in
+            if channels.count != 1 {
+                result = false
+                return
+            }
+            let player: AVAudioPlayer = channels[playIndex]
+            result = player.isPlaying
         }
+        return result
+    }
+
+    internal func startCurrentTimeUpdates() {
+        NSLog("Starting timer updates")
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                NSLog("Self is nil in timer start")
+                return
+            }
+
+            self.currentTimeTimer?.invalidate()
+            self.currentTimeTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+                guard let self = self else {
+                    NSLog("Self is nil in timer callback")
+                    return
+                }
+
+                var shouldNotify = false
+                var currentTime: TimeInterval = 0
 
-        let player: AVAudioPlayer = channels[playIndex]
-        return player.isPlaying
+                self.owner.executeOnAudioQueue {
+                    shouldNotify = self.isPlaying()
+                    NSLog("isPlaying returned: \(shouldNotify)")
+                    if shouldNotify {
+                        currentTime = self.getCurrentTime()
+                        NSLog("getCurrentTime returned: \(currentTime)")
+                    }
+                }
+
+                if shouldNotify {
+                    NSLog("Calling notifyCurrentTime")
+                    self.owner.notifyCurrentTime(self)
+                } else {
+                    NSLog("Stopping timer - not playing")
+                    self.stopCurrentTimeUpdates()
+                }
+            }
+            RunLoop.current.add(self.currentTimeTimer!, forMode: .common)
+            NSLog("Timer added to RunLoop")
+        }
+    }
+
+    internal func stopCurrentTimeUpdates() {
+        DispatchQueue.main.async { [weak self] in
+            self?.currentTimeTimer?.invalidate()
+            self?.currentTimeTimer = nil
+        }
     }
 }

package/ios/Plugin/Plugin.swift

@@ -10,7 +10,7 @@ enum MyError: Error {
 /// Please read the Capacitor iOS Plugin Development Guide
 /// here: https://capacitor.ionicframework.com/docs/plugins/ios
 @objc(NativeAudio)
-public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
+public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate, CAPBridgedPlugin {
     public let identifier = "NativeAudio"
     public let jsName = "NativeAudio"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -28,9 +28,10 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
         CAPPluginMethod(name: "getCurrentTime", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getDuration", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "resume", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "setCurrentTime", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "setCurrentTime", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearCache", returnType: CAPPluginReturnPromise)
     ]
-    private let audioQueue = DispatchQueue(label: "ee.forgr.audio.queue", qos: .userInitiated)
+    internal let audioQueue = DispatchQueue(label: "ee.forgr.audio.queue", qos: .userInitiated, attributes: .concurrent)
     private var audioList: [String: Any] = [:] {
         didSet {
             // Ensure audioList modifications happen on audioQueue
@@ -165,18 +166,13 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
         let time = call.getDouble("time") ?? 0
         let delay = call.getDouble("delay") ?? 0
 
-        if audioId.isEmpty {
-            call.reject(Constant.ErrorAssetId)
-            return
-        }
-
-        audioQueue.async {
-            guard !self.audioList.isEmpty else {
+        audioQueue.sync { [self] in  // Changed from async to sync for consistency
+            guard !audioList.isEmpty else {
                 call.reject("Audio list is empty")
                 return
             }
 
-            guard let asset = self.audioList[audioId] else {
+            guard let asset = audioList[audioId] else {
                 call.reject(Constant.ErrorAssetNotFound)
                 return
             }
@@ -200,29 +196,9 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
     }
 
     @objc private func getAudioAsset(_ call: CAPPluginCall) -> AudioAsset? {
-        let audioId = call.getString(Constant.AssetIdKey) ?? ""
-        if audioId.isEmpty {
-            call.reject(Constant.ErrorAssetId)
-            return nil
-        }
-
         var asset: AudioAsset?
-        audioQueue.sync {
-            if self.audioList.isEmpty {
-                call.reject("Audio list is empty")
-                return
-            }
-
-            guard let foundAsset = self.audioList[audioId] as? AudioAsset else {
-                call.reject(Constant.ErrorAssetNotFound + " - " + audioId)
-                return
-            }
-            asset = foundAsset
-        }
-
-        if asset == nil {
-            call.reject("Failed to get audio asset")
-            return nil
+        audioQueue.sync { [self] in  // Read operation
+            asset = self.audioList[call.getString(Constant.AssetIdKey) ?? ""] as? AudioAsset
         }
         return asset
     }
@@ -380,12 +356,20 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
         }
     }
 
-    private func preloadAsset(_ call: CAPPluginCall, isComplex complex: Bool) {
+    @objc func clearCache(_ call: CAPPluginCall) {
+        audioQueue.async {
+            RemoteAudioAsset.clearCache()
+            call.resolve()
+        }
+    }
+
+    @objc private func preloadAsset(_ call: CAPPluginCall, isComplex complex: Bool) {
         let audioId = call.getString(Constant.AssetIdKey) ?? ""
         let channels: Int?
         let volume: Float?
         let delay: Float?
         var isLocalUrl: Bool = call.getBool("isUrl") ?? false
+
         if audioId == "" {
             call.reject(Constant.ErrorAssetId)
             return
@@ -397,23 +381,22 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
             channels = call.getInt("channels") ?? 1
             delay = call.getFloat("delay") ?? 1.0
         } else {
-            channels = 0
-            volume = 0
-            delay = 0
+            channels = 1
+            volume = 1.0
+            delay = 0.0
             isLocalUrl = false
         }
 
-        if audioList.isEmpty {
-            audioList = [:]
-        }
+        audioQueue.sync(flags: .barrier) { [self] in
+            if audioList.isEmpty {
+                audioList = [:]
+            }
+
+            if audioList[audioId] != nil {
+                call.reject(Constant.ErrorAssetAlreadyLoaded + " - " + audioId)
+                return
+            }
 
-        let asset = audioList[audioId]
-        let queue = DispatchQueue(label: "ee.forgr.audio.simple.queue", qos: .userInitiated)
-        if asset != nil {
-            call.reject(Constant.ErrorAssetAlreadyLoaded + " - " + audioId)
-            return
-        }
-        queue.async {
             var basePath: String?
             if let url = URL(string: assetPath), url.scheme != nil {
                 // Handle remote URL
@@ -423,9 +406,7 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
                 return
             } else if isLocalUrl == false {
                 // Handle public folder
-                // if assetPath doesnt start with public/ add it
                 assetPath = assetPath.starts(with: "public/") ? assetPath : "public/" + assetPath
-
                 let assetPathSplit = assetPath.components(separatedBy: ".")
                 basePath = Bundle.main.path(forResource: assetPathSplit[0], ofType: assetPathSplit[1])
             } else {
@@ -482,9 +463,34 @@ public class NativeAudio: CAPPlugin, AVAudioPlayerDelegate {
         }
 
         if self.fadeMusic {
-            audioAsset.playWithFade(time: audioAsset.getCurrentTime())
+            audioAsset.stopWithFade()
         } else {
             audioAsset.stop()
         }
     }
+
+    internal func executeOnAudioQueue(_ block: @escaping () -> Void) {
+        if DispatchQueue.getSpecific(key: queueKey) != nil {
+            block()  // Already on queue
+        } else {
+            audioQueue.sync(flags: .barrier) {
+                block()
+            }
+        }
+    }
+
+    @objc func notifyCurrentTime(_ asset: AudioAsset) {
+        NSLog("notifyCurrentTime called in Plugin")
+        audioQueue.sync {
+            let rawTime = asset.getCurrentTime()
+            // Round to nearest 100ms (0.1 seconds)
+            let currentTime = round(rawTime * 10) / 10
+            NSLog("About to notify listeners with time: \(currentTime)")
+            notifyListeners("currentTime", data: [
+                "currentTime": currentTime,
+                "assetId": asset.assetId
+            ])
+            NSLog("Listeners notified")
+        }
+    }
 }