@capgo/native-audio 6.4.5 → 6.4.7

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

@@ -12,7 +12,7 @@ public class AudioAsset {
   private final ArrayList<AudioDispatcher> audioList;
   private int playIndex = 0;
   private final String assetId;
-  private final NativeAudio owner;
+  protected final NativeAudio owner;
 
   AudioAsset(
     NativeAudio owner,

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

@@ -29,7 +29,11 @@ import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
 import com.getcapacitor.annotation.Permission;
 import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.IOException;
 import java.net.URI;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.HashMap;
 
@@ -56,6 +60,8 @@ public class NativeAudio
 
     this.audioManager = (AudioManager) this.getActivity()
       .getSystemService(Context.AUDIO_SERVICE);
+
+    audioAssetList = new HashMap<>();
   }
 
   @Override
@@ -448,88 +454,132 @@ public class NativeAudio
       initSoundPool();
 
       String audioId = call.getString(ASSET_ID);
-
-      boolean isLocalUrl = Boolean.TRUE.equals(call.getBoolean("isUrl", false));
-
       if (!isStringValid(audioId)) {
         call.reject(ERROR_AUDIO_ID_MISSING + " - " + audioId);
         return;
       }
 
-      if (!audioAssetList.containsKey(audioId)) {
-        String assetPath = call.getString(ASSET_PATH);
+      String assetPath = call.getString(ASSET_PATH);
+      if (!isStringValid(assetPath)) {
+        call.reject(
+          ERROR_ASSET_PATH_MISSING + " - " + audioId + " - " + assetPath
+        );
+        return;
+      }
 
-        if (!isStringValid(assetPath)) {
-          call.reject(
-            ERROR_ASSET_PATH_MISSING + " - " + audioId + " - " + assetPath
-          );
-          return;
-        }
+      boolean isLocalUrl = call.getBoolean("isUrl", false);
+      boolean isComplex = call.getBoolean("isComplex", false);
 
-        String fullPath = assetPath; //"raw/".concat(assetPath);
+      Log.d(
+        "AudioPlugin",
+        "Debug: audioId = " +
+        audioId +
+        ", assetPath = " +
+        assetPath +
+        ", isLocalUrl = " +
+        isLocalUrl
+      );
 
+      if (audioAssetList.containsKey(audioId)) {
+        call.reject(ERROR_AUDIO_EXISTS + " - " + audioId);
+        return;
+      }
+
+      if (isComplex) {
         volume = call.getFloat(VOLUME, 1F);
         audioChannelNum = call.getInt(AUDIO_CHANNEL_NUM, 1);
+      }
 
-        AssetFileDescriptor assetFileDescriptor;
-        if (isLocalUrl) {
-          File f = new File(new URI(fullPath));
-          ParcelFileDescriptor p = ParcelFileDescriptor.open(
-            f,
-            ParcelFileDescriptor.MODE_READ_ONLY
-          );
-          assetFileDescriptor = new AssetFileDescriptor(p, 0, -1);
-        } else {
-          try {
-            Uri uri = Uri.parse(fullPath); // Now Uri class should be recognized
-            if (
-              uri.getScheme() != null &&
-              (uri.getScheme().equals("http") ||
-                uri.getScheme().equals("https"))
-            ) {
-              // It's a remote URL
-              RemoteAudioAsset remoteAudioAsset = new RemoteAudioAsset(
-                this,
-                audioId,
-                uri,
-                audioChannelNum,
-                volume
+      if (isLocalUrl) {
+        // Handle URL (both remote and local file URLs)
+        Log.d("AudioPlugin", "Debug: Handling URL");
+        try {
+          Uri uri = Uri.parse(assetPath);
+          if (
+            uri.getScheme() != null &&
+            (uri.getScheme().equals("http") || uri.getScheme().equals("https"))
+          ) {
+            // Remote URL
+            Log.d(
+              "AudioPlugin",
+              "Debug: Remote URL detected: " + uri.toString()
+            );
+            RemoteAudioAsset remoteAudioAsset = new RemoteAudioAsset(
+              this,
+              audioId,
+              uri,
+              audioChannelNum,
+              volume
+            );
+            audioAssetList.put(audioId, remoteAudioAsset);
+          } else if (
+            uri.getScheme() != null && uri.getScheme().equals("file")
+          ) {
+            // Local file URL
+            Log.d("AudioPlugin", "Debug: Local file URL detected");
+            File file = new File(uri.getPath());
+            if (!file.exists()) {
+              Log.e(
+                "AudioPlugin",
+                "Error: File does not exist - " + file.getAbsolutePath()
               );
-              audioAssetList.put(audioId, remoteAudioAsset);
-              call.resolve(status);
+              call.reject(ERROR_ASSET_PATH_MISSING + " - " + assetPath);
               return;
-            } else {
-              // It's a local file path
-              // Check if fullPath starts with "public/" and prepend if necessary
-              if (!fullPath.startsWith("public/")) {
-                fullPath = "public/".concat(fullPath);
-              }
-              Context ctx = getContext().getApplicationContext(); // Use getContext() directly
-              AssetManager am = ctx.getResources().getAssets();
-              // Remove the redefinition of assetFileDescriptor
-              assetFileDescriptor = am.openFd(fullPath);
             }
-          } catch (Exception e) {
-            call.reject("Error loading audio", e);
-            return;
+            ParcelFileDescriptor pfd = ParcelFileDescriptor.open(
+              file,
+              ParcelFileDescriptor.MODE_READ_ONLY
+            );
+            AssetFileDescriptor afd = new AssetFileDescriptor(
+              pfd,
+              0,
+              AssetFileDescriptor.UNKNOWN_LENGTH
+            );
+            AudioAsset asset = new AudioAsset(
+              this,
+              audioId,
+              afd,
+              audioChannelNum,
+              volume
+            );
+            audioAssetList.put(audioId, asset);
+          } else {
+            throw new IllegalArgumentException(
+              "Invalid URL scheme: " + uri.getScheme()
+            );
           }
+          call.resolve(status);
+        } catch (Exception e) {
+          Log.e("AudioPlugin", "Error handling URL", e);
+          call.reject("Error handling URL: " + e.getMessage());
         }
-
-        AudioAsset asset = new AudioAsset(
-          this,
-          audioId,
-          assetFileDescriptor,
-          audioChannelNum,
-          volume
-        );
-        audioAssetList.put(audioId, asset);
-
-        call.resolve(status);
       } else {
-        call.reject(ERROR_AUDIO_EXISTS);
+        // Handle asset in public folder
+        Log.d("AudioPlugin", "Debug: Handling asset in public folder");
+        if (!assetPath.startsWith("public/")) {
+          assetPath = "public/" + assetPath;
+        }
+        try {
+          Context ctx = getContext().getApplicationContext();
+          AssetManager am = ctx.getResources().getAssets();
+          AssetFileDescriptor assetFileDescriptor = am.openFd(assetPath);
+          AudioAsset asset = new AudioAsset(
+            this,
+            audioId,
+            assetFileDescriptor,
+            audioChannelNum,
+            volume
+          );
+          audioAssetList.put(audioId, asset);
+          call.resolve(status);
+        } catch (IOException e) {
+          Log.e("AudioPlugin", "Error opening asset: " + assetPath, e);
+          call.reject(ERROR_ASSET_PATH_MISSING + " - " + assetPath);
+        }
       }
     } catch (Exception ex) {
-      call.reject(ex.getMessage());
+      Log.e("AudioPlugin", "Error in preloadAsset", ex);
+      call.reject("Error in preloadAsset: " + ex.getMessage());
     }
   }
 

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

@@ -2,10 +2,17 @@ package ee.forgr.audio;
 
 import android.media.MediaPlayer;
 import android.net.Uri;
+import android.util.Log;
+import java.util.ArrayList;
 
 public class RemoteAudioAsset extends AudioAsset {
 
-  private MediaPlayer mediaPlayer;
+  private static final String TAG = "RemoteAudioAsset";
+  private final ArrayList<MediaPlayer> mediaPlayers;
+  private int playIndex = 0;
+  private final Uri uri;
+  private float volume;
+  private boolean isPrepared = false;
 
   public RemoteAudioAsset(
     NativeAudio owner,
@@ -14,74 +21,155 @@ public class RemoteAudioAsset extends AudioAsset {
     int audioChannelNum,
     float volume
   ) throws Exception {
-    super(owner, assetId, null, audioChannelNum, volume);
-    mediaPlayer = new MediaPlayer();
-    mediaPlayer.setDataSource(owner.getContext(), uri);
-    mediaPlayer.setVolume(volume, volume);
-    mediaPlayer.prepareAsync(); // Prepare asynchronously to not block the main thread
+    super(owner, assetId, null, 0, volume);
+    this.uri = uri;
+    this.volume = volume;
+    this.mediaPlayers = new ArrayList<>();
+
+    if (audioChannelNum < 1) {
+      audioChannelNum = 1;
+    }
+
+    for (int i = 0; i < audioChannelNum; i++) {
+      MediaPlayer mediaPlayer = new MediaPlayer();
+      mediaPlayers.add(mediaPlayer);
+      initializeMediaPlayer(mediaPlayer);
+    }
+  }
+
+  private void initializeMediaPlayer(MediaPlayer mediaPlayer) {
+    try {
+      mediaPlayer.setDataSource(owner.getContext(), uri);
+      mediaPlayer.setVolume(volume, volume);
+      mediaPlayer.setOnPreparedListener(mp -> {
+        isPrepared = true;
+        Log.d(TAG, "MediaPlayer prepared for " + uri.toString());
+      });
+      mediaPlayer.setOnErrorListener((mp, what, extra) -> {
+        Log.e(TAG, "MediaPlayer error: " + what + ", " + extra);
+        return false;
+      });
+      mediaPlayer.prepareAsync();
+    } catch (Exception e) {
+      Log.e(TAG, "Error initializing MediaPlayer", e);
+    }
   }
 
   @Override
   public void play(Double time) throws Exception {
-    if (mediaPlayer != null) {
-      if (time != null) {
-        mediaPlayer.seekTo((int) (time * 1000));
-      }
-      mediaPlayer.start();
+    if (mediaPlayers.isEmpty()) {
+      throw new Exception("No MediaPlayer available");
+    }
+
+    MediaPlayer mediaPlayer = mediaPlayers.get(playIndex);
+    if (!isPrepared) {
+      Log.d(TAG, "MediaPlayer not yet prepared, waiting...");
+      mediaPlayer.setOnPreparedListener(mp -> {
+        isPrepared = true;
+        try {
+          playInternal(mediaPlayer, time);
+        } catch (Exception e) {
+          Log.e(TAG, "Error playing after prepare", e);
+        }
+      });
     } else {
-      throw new Exception("MediaPlayer is null");
+      playInternal(mediaPlayer, time);
+    }
+
+    playIndex = (playIndex + 1) % mediaPlayers.size();
+  }
+
+  private void playInternal(MediaPlayer mediaPlayer, Double time)
+    throws Exception {
+    if (time != null) {
+      mediaPlayer.seekTo((int) (time * 1000));
     }
+    mediaPlayer.start();
   }
 
   @Override
   public boolean pause() throws Exception {
-    if (mediaPlayer != null && mediaPlayer.isPlaying()) {
-      mediaPlayer.pause();
-      return true; // Return true to indicate that the audio was paused
+    boolean wasPlaying = false;
+    for (MediaPlayer mediaPlayer : mediaPlayers) {
+      if (mediaPlayer.isPlaying()) {
+        mediaPlayer.pause();
+        wasPlaying = true;
+      }
     }
-    return false;
+    return wasPlaying;
   }
 
   @Override
   public void resume() throws Exception {
-    if (mediaPlayer != null && !mediaPlayer.isPlaying()) {
-      mediaPlayer.start();
+    for (MediaPlayer mediaPlayer : mediaPlayers) {
+      if (!mediaPlayer.isPlaying()) {
+        mediaPlayer.start();
+      }
     }
   }
 
   @Override
   public void stop() throws Exception {
-    if (mediaPlayer != null) {
-      mediaPlayer.stop();
-      mediaPlayer.prepare(); // Call prepare to reset the MediaPlayer to the Idle state
+    for (MediaPlayer mediaPlayer : mediaPlayers) {
+      if (mediaPlayer.isPlaying()) {
+        mediaPlayer.stop();
+      }
+      // Reset the MediaPlayer to make it ready for future playback
+      mediaPlayer.reset();
+      initializeMediaPlayer(mediaPlayer);
     }
+    isPrepared = false;
   }
 
   @Override
   public void loop() throws Exception {
-    if (mediaPlayer != null) {
+    if (!mediaPlayers.isEmpty()) {
+      MediaPlayer mediaPlayer = mediaPlayers.get(playIndex);
       mediaPlayer.setLooping(true);
       mediaPlayer.start();
+      playIndex = (playIndex + 1) % mediaPlayers.size();
     }
   }
 
   @Override
   public void unload() throws Exception {
-    if (mediaPlayer != null) {
+    for (MediaPlayer mediaPlayer : mediaPlayers) {
       mediaPlayer.release();
-      mediaPlayer = null;
     }
+    mediaPlayers.clear();
   }
 
   @Override
   public void setVolume(float volume) throws Exception {
-    if (mediaPlayer != null) {
+    this.volume = volume;
+    for (MediaPlayer mediaPlayer : mediaPlayers) {
       mediaPlayer.setVolume(volume, volume);
     }
   }
 
   @Override
   public boolean isPlaying() throws Exception {
-    return mediaPlayer != null && mediaPlayer.isPlaying();
+    for (MediaPlayer mediaPlayer : mediaPlayers) {
+      if (mediaPlayer.isPlaying()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public double getDuration() {
+    if (!mediaPlayers.isEmpty() && isPrepared) {
+      return mediaPlayers.get(0).getDuration() / 1000.0;
+    }
+    return 0;
+  }
+
+  @Override
+  public double getCurrentPosition() {
+    if (!mediaPlayers.isEmpty() && isPrepared) {
+      return mediaPlayers.get(0).getCurrentPosition() / 1000.0;
+    }
+    return 0;
   }
 }

package/package.json

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