@capgo/native-audio 6.4.20 → 6.4.22

package/android/src/main/java/ee/forgr/audio/AudioAsset.java

@@ -13,6 +13,7 @@ public class AudioAsset {
   private int playIndex = 0;
   private final String assetId;
   protected final NativeAudio owner;
+  protected AudioCompletionListener completionListener;
 
   AudioAsset(
     NativeAudio owner,
@@ -167,4 +168,14 @@ public class AudioAsset {
 
     return audioList.get(playIndex).isPlaying();
   }
+
+  public void setCompletionListener(AudioCompletionListener listener) {
+    this.completionListener = listener;
+  }
+
+  protected void notifyCompletion() {
+    if (completionListener != null) {
+      completionListener.onCompletion(this.assetId);
+    }
+  }
 }

package/android/src/main/java/ee/forgr/audio/AudioCompletionListener.java

@@ -0,0 +1,5 @@
+package ee.forgr.audio;
+
+public interface AudioCompletionListener {
+  void onCompletion(String assetId);
+}

package/android/src/main/java/ee/forgr/audio/AudioDispatcher.java

@@ -118,7 +118,7 @@ public class AudioDispatcher
         this.stop();
 
         if (this.owner != null) {
-          this.owner.dispatchComplete();
+          this.owner.notifyCompletion();
         }
       }
     } catch (Exception ex) {

package/android/src/main/java/ee/forgr/audio/NativeAudio.java

@@ -504,6 +504,7 @@ public class NativeAudio
               audioChannelNum,
               volume
             );
+            remoteAudioAsset.setCompletionListener(this::dispatchComplete);
             audioAssetList.put(audioId, remoteAudioAsset);
           } else if (
             uri.getScheme() != null && uri.getScheme().equals("file")
@@ -535,6 +536,7 @@ public class NativeAudio
               audioChannelNum,
               volume
             );
+            asset.setCompletionListener(this::dispatchComplete);
             audioAssetList.put(audioId, asset);
           } else {
             throw new IllegalArgumentException(

package/android/src/main/java/ee/forgr/audio/RemoteAudioAsset.java

@@ -45,6 +45,9 @@ public class RemoteAudioAsset extends AudioAsset {
         isPrepared = true;
         Log.d(TAG, "MediaPlayer prepared for " + uri.toString());
       });
+      mediaPlayer.setOnCompletionListener(mp -> {
+        notifyCompletion();
+      });
       mediaPlayer.setOnErrorListener((mp, what, extra) -> {
         Log.e(TAG, "MediaPlayer error: " + what + ", " + extra);
         return false;

package/ios/Plugin/RemoteAudioAsset.swift

@@ -1,74 +1,118 @@
 import AVFoundation
 
 public class RemoteAudioAsset: AudioAsset {
-    var playerItem: AVPlayerItem?
-    var player: AVPlayer?
+    var playerItems: [AVPlayerItem] = []
+    var players: [AVPlayer] = []
+    var playerObservers: [NSKeyValueObservation] = []
 
     override init(owner: NativeAudio, withAssetId assetId: String, withPath path: String!, withChannels channels: Int!, withVolume volume: Float!, withFadeDelay delay: Float!) {
         super.init(owner: owner, withAssetId: assetId, withPath: path, withChannels: channels, withVolume: volume, withFadeDelay: delay)
 
         if let url = URL(string: path) {
-            self.playerItem = AVPlayerItem(url: url)
-            self.player = AVPlayer(playerItem: self.playerItem)
-            self.player?.volume = volume
+            for _ in 0..<channels {
+                let playerItem = AVPlayerItem(url: url)
+                let player = AVPlayer(playerItem: playerItem)
+                player.volume = volume
+                self.playerItems.append(playerItem)
+                self.players.append(player)
+
+                // Add observer for playback finished
+                let observer = player.observe(\.timeControlStatus) { [weak self] player, _ in
+                    if player.timeControlStatus == .paused && player.currentItem?.currentTime() == player.currentItem?.duration {
+                        self?.playerDidFinishPlaying(player: player)
+                    }
+                }
+                self.playerObservers.append(observer)
+            }
         }
     }
 
+    func playerDidFinishPlaying(player: AVPlayer) {
+        self.owner.notifyListeners("complete", data: [
+            "assetId": self.assetId
+        ])
+    }
+
     override func play(time: TimeInterval, delay: TimeInterval) {
-        guard let player = self.player else { return }
+        guard !players.isEmpty else { return }
+        let player = players[playIndex]
         if delay > 0 {
-            // Calculate the future time to play
             let timeToPlay = CMTimeAdd(CMTimeMakeWithSeconds(player.currentTime().seconds, preferredTimescale: 1), CMTimeMakeWithSeconds(delay, preferredTimescale: 1))
             player.seek(to: timeToPlay)
         } else {
             player.seek(to: CMTimeMakeWithSeconds(time, preferredTimescale: 1))
         }
         player.play()
+        playIndex = (playIndex + 1) % players.count
     }
 
     override func pause() {
-        player?.pause()
+        guard !players.isEmpty else { return }
+        let player = players[playIndex]
+        player.pause()
     }
 
     override func resume() {
-        player?.play()
+        guard !players.isEmpty else { return }
+        let player = players[playIndex]
+        player.play()
     }
 
     override func stop() {
-        player?.pause()
-        player?.seek(to: CMTime.zero)
+        for player in players {
+            player.pause()
+            player.seek(to: CMTime.zero)
+        }
     }
 
     override func loop() {
-        player?.actionAtItemEnd = .none
-        NotificationCenter.default.addObserver(self,
-                                               selector: #selector(playerItemDidReachEnd(notification:)),
-                                               name: .AVPlayerItemDidPlayToEndTime,
-                                               object: player?.currentItem)
-        player?.play()
+        for player in players {
+            player.actionAtItemEnd = .none
+            NotificationCenter.default.addObserver(self,
+                                                   selector: #selector(playerItemDidReachEnd(notification:)),
+                                                   name: .AVPlayerItemDidPlayToEndTime,
+                                                   object: player.currentItem)
+            player.play()
+        }
     }
 
     @objc func playerItemDidReachEnd(notification: Notification) {
-        player?.seek(to: CMTime.zero)
-        player?.play()
+        guard let player = notification.object as? AVPlayer else { return }
+        player.seek(to: CMTime.zero)
+        player.play()
     }
 
     override func unload() {
         stop()
         NotificationCenter.default.removeObserver(self)
-        player = nil
-        playerItem = nil
+        // Remove KVO observers
+        for observer in playerObservers {
+            observer.invalidate()
+        }
+        playerObservers = []
+        players = []
+        playerItems = []
     }
 
     override func setVolume(volume: NSNumber!) {
-        player?.volume = volume.floatValue
+        for player in players {
+            player.volume = volume.floatValue
+        }
     }
 
     override func setRate(rate: NSNumber!) {
-        player?.rate = rate.floatValue
+        for player in players {
+            player.rate = rate.floatValue
+        }
     }
 
     override func isPlaying() -> Bool {
-        return player?.timeControlStatus == .playing
+        return players.contains { $0.timeControlStatus == .playing }
+    }
+
+    override func getCurrentTime() -> TimeInterval {
+        guard !players.isEmpty else { return 0 }
+        let player = players[playIndex]
+        return player.currentTime().seconds
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/native-audio",
-  "version": "6.4.20",
+  "version": "6.4.22",
   "description": "A native plugin for native audio engine",
   "main": "dist/plugin.js",
   "module": "dist/esm/index.js",