@capgo/capacitor-native-audio 8.4.3

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

@@ -0,0 +1,208 @@
+package ee.forgr.audio;
+
+import static ee.forgr.audio.Constant.INVALID;
+import static ee.forgr.audio.Constant.LOOPING;
+import static ee.forgr.audio.Constant.PAUSE;
+import static ee.forgr.audio.Constant.PENDING_LOOP;
+import static ee.forgr.audio.Constant.PENDING_PLAY;
+import static ee.forgr.audio.Constant.PLAYING;
+import static ee.forgr.audio.Constant.PREPARED;
+
+import android.content.res.AssetFileDescriptor;
+import android.media.AudioAttributes;
+import android.media.MediaPlayer;
+import android.os.Build;
+import android.util.Log;
+import androidx.media3.common.util.UnstableApi;
+
+@UnstableApi
+public class AudioDispatcher
+    implements MediaPlayer.OnPreparedListener, MediaPlayer.OnCompletionListener, MediaPlayer.OnSeekCompleteListener
+{
+
+    private final String TAG = "AudioDispatcher";
+    private final MediaPlayer mediaPlayer;
+    private int mediaState;
+    private AudioAsset owner;
+
+    private float currentVolume = 1.0f;
+
+    public AudioDispatcher(AssetFileDescriptor assetFileDescriptor, float volume) throws Exception {
+        mediaState = INVALID;
+
+        mediaPlayer = new MediaPlayer();
+        mediaPlayer.setOnCompletionListener(this);
+        mediaPlayer.setOnPreparedListener(this);
+        mediaPlayer.setDataSource(
+            assetFileDescriptor.getFileDescriptor(),
+            assetFileDescriptor.getStartOffset(),
+            assetFileDescriptor.getLength()
+        );
+        mediaPlayer.setOnSeekCompleteListener(this);
+        mediaPlayer.setAudioAttributes(
+            new AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_MEDIA)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                .build()
+        );
+        mediaPlayer.setVolume(volume, volume);
+        currentVolume = volume;
+        mediaPlayer.setPlaybackParams(mediaPlayer.getPlaybackParams().setSpeed(1.0f));
+        mediaPlayer.prepare();
+    }
+
+    public void setOwner(AudioAsset asset) {
+        owner = asset;
+    }
+
+    public double getDuration() {
+        return mediaPlayer.getDuration() / 1000.0;
+    }
+
+    public void setCurrentPosition(double time) {
+        if (mediaState == PLAYING || mediaState == PAUSE) {
+            mediaPlayer.seekTo((int) (time * 1000));
+        }
+    }
+
+    public double getCurrentPosition() {
+        return mediaPlayer.getCurrentPosition() / 1000.0;
+    }
+
+    public void play(Double time) throws Exception {
+        invokePlay(time);
+    }
+
+    public boolean pause() throws Exception {
+        if (mediaPlayer.isPlaying()) {
+            mediaPlayer.pause();
+            mediaState = PAUSE;
+            return true;
+        }
+
+        return false;
+    }
+
+    public void resume() throws Exception {
+        mediaPlayer.start();
+    }
+
+    public void stop() throws Exception {
+        if (mediaPlayer.isPlaying()) {
+            mediaState = INVALID;
+            mediaPlayer.pause();
+            mediaPlayer.seekTo(0);
+        }
+    }
+
+    public void setVolume(float volume) throws Exception {
+        mediaPlayer.setVolume(volume, volume);
+        currentVolume = volume;
+    }
+
+    public float getVolume() {
+        return currentVolume;
+    }
+
+    public void setRate(float rate) throws Exception {
+        mediaPlayer.setPlaybackParams(mediaPlayer.getPlaybackParams().setSpeed(rate));
+    }
+
+    public void loop() throws Exception {
+        mediaPlayer.setLooping(true);
+        mediaPlayer.start();
+    }
+
+    public void unload() throws Exception {
+        this.stop();
+        mediaPlayer.release();
+    }
+
+    @Override
+    public void onCompletion(MediaPlayer mp) {
+        try {
+            if (mediaState != LOOPING) {
+                this.mediaState = INVALID;
+
+                this.stop();
+
+                if (this.owner != null) {
+                    this.owner.notifyCompletion();
+                }
+            }
+        } catch (Exception ex) {
+            Log.d(TAG, "Caught exception while listening for onCompletion: " + ex.getLocalizedMessage());
+        }
+    }
+
+    @Override
+    public void onPrepared(MediaPlayer mp) {
+        try {
+            if (mediaState == PENDING_PLAY) {
+                mediaPlayer.setLooping(false);
+            } else if (mediaState == PENDING_LOOP) {
+                mediaPlayer.setLooping(true);
+            } else {
+                mediaState = PREPARED;
+            }
+        } catch (Exception ex) {
+            Log.d(TAG, "Caught exception while listening for onPrepared: " + ex.getLocalizedMessage());
+        }
+    }
+
+    private void seek(Double time) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            mediaPlayer.seekTo((int) (time * 1000), MediaPlayer.SEEK_NEXT_SYNC);
+        } else {
+            mediaPlayer.seekTo((int) (time * 1000));
+        }
+    }
+
+    private void invokePlay(Double time) {
+        try {
+            boolean playing = mediaPlayer.isPlaying();
+
+            if (playing) {
+                mediaPlayer.pause();
+                mediaPlayer.setLooping(false);
+                mediaState = PENDING_PLAY;
+                seek(time);
+            } else {
+                if (mediaState == PREPARED) {
+                    mediaState = (PENDING_PLAY);
+                    onPrepared(mediaPlayer);
+                    seek(time);
+                } else {
+                    mediaState = (PENDING_PLAY);
+                    mediaPlayer.setLooping(false);
+                    seek(time);
+                }
+            }
+        } catch (Exception ex) {
+            Log.d(TAG, "Caught exception while invoking audio: " + ex.getLocalizedMessage());
+        }
+    }
+
+    @Override
+    public void onSeekComplete(MediaPlayer mp) {
+        if (mediaState == PENDING_PLAY || mediaState == PENDING_LOOP) {
+            Log.w("AudioDispatcher", "play " + mediaState);
+            mediaPlayer.start();
+            mediaState = PLAYING;
+        }
+    }
+
+    public boolean isPlaying() {
+        boolean playing = false;
+        try {
+            playing = mediaPlayer.isPlaying();
+        } catch (IllegalStateException ex) {
+            Log.v(TAG, "Caught exception while checking if audio is playing: " + ex.getLocalizedMessage());
+        }
+        return playing;
+    }
+
+    public boolean isPaused() {
+        return mediaState == PAUSE;
+    }
+}

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

@@ -0,0 +1,36 @@
+package ee.forgr.audio;
+
+public class Constant {
+
+    public static final String ERROR_AUDIO_ID_MISSING = "Audio Id is missing";
+    public static final String ERROR_AUDIO_ASSET_MISSING = "Audio Asset is missing";
+    public static final String ERROR_AUDIO_EXISTS = "Audio Asset already exists";
+    public static final String ERROR_ASSET_PATH_MISSING = "Asset Path is missing";
+    public static final String ERROR_ASSET_NOT_LOADED = "Asset is not loaded";
+
+    public static final String ASSET_ID = "assetId";
+    public static final String ASSET_PATH = "assetPath";
+    public static final String OPT_FOCUS_AUDIO = "focus";
+    public static final String TIME = "time";
+    public static final String DELAY = "delay";
+    public static final String VOLUME = "volume";
+    public static final String RATE = "rate";
+    public static final String DURATION = "duration";
+    public static final String AUDIO_CHANNEL_NUM = "audioChannelNum";
+    public static final String LOOP = "loop";
+    public static final String PLAY = "play";
+    public static final String FADE_IN = "fadeIn";
+    public static final String FADE_OUT = "fadeOut";
+    public static final String FADE_IN_DURATION = "fadeInDuration";
+    public static final String FADE_OUT_DURATION = "fadeOutDuration";
+    public static final String FADE_OUT_START_TIME = "fadeOutStartTime";
+    public static final String SHOW_NOTIFICATION = "showNotification";
+    public static final String NOTIFICATION_METADATA = "notificationMetadata";
+    public static final int INVALID = 0;
+    public static final int PREPARED = 1;
+    public static final int PENDING_PLAY = 2;
+    public static final int PLAYING = 3;
+    public static final int PENDING_LOOP = 4;
+    public static final int LOOPING = 5;
+    public static final int PAUSE = 6;
+}

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

@@ -0,0 +1,84 @@
+package ee.forgr.audio;
+
+import android.util.Log;
+
+/**
+ * Utility class to check if HLS (m3u8) streaming dependencies are available at runtime.
+ *
+ * This allows the plugin to gracefully handle cases where the HLS dependency
+ * (media3-exoplayer-hls) is excluded to reduce APK size.
+ *
+ * Users who don't need HLS streaming support can disable it in capacitor.config.ts:
+ *
+ * plugins: {
+ *   NativeAudio: {
+ *     hls: false  // Reduces APK size by ~4MB
+ *   }
+ * }
+ */
+public class HlsAvailabilityChecker {
+
+    private static final String TAG = "HlsAvailabilityChecker";
+    private static Boolean hlsAvailable = null;
+
+    /**
+     * Check if a class is available at runtime using reflection.
+     */
+    private static boolean isClassAvailable(String className) {
+        try {
+            Class.forName(className);
+            return true;
+        } catch (ClassNotFoundException e) {
+            return false;
+        } catch (Exception e) {
+            Log.e(TAG, "Unexpected error checking class availability: " + className, e);
+            return false;
+        }
+    }
+
+    /**
+     * Check if HLS streaming dependencies are available.
+     * Results are cached for performance.
+     *
+     * @return true if HLS classes are available, false otherwise
+     */
+    public static boolean isHlsAvailable() {
+        if (hlsAvailable != null) {
+            return hlsAvailable;
+        }
+
+        // Check for the critical HLS classes from media3-exoplayer-hls
+        String[] hlsClasses = { "androidx.media3.exoplayer.hls.HlsMediaSource", "androidx.media3.exoplayer.hls.HlsMediaSource$Factory" };
+
+        boolean allAvailable = true;
+        for (String className : hlsClasses) {
+            if (!isClassAvailable(className)) {
+                allAvailable = false;
+                Log.w(TAG, "HLS dependency class not available: " + className);
+            }
+        }
+
+        hlsAvailable = allAvailable;
+
+        if (!allAvailable) {
+            Log.i(
+                TAG,
+                "HLS streaming support is not available. " +
+                    "To enable m3u8 streaming, set 'hls: true' in capacitor.config.ts under NativeAudio plugin config " +
+                    "and run 'npx cap sync'."
+            );
+        } else {
+            Log.d(TAG, "HLS streaming support is available.");
+        }
+
+        return allAvailable;
+    }
+
+    /**
+     * Reset the cached availability check.
+     * Useful for testing purposes.
+     */
+    public static void resetCache() {
+        hlsAvailable = null;
+    }
+}

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

@@ -0,0 +1,55 @@
+package ee.forgr.audio;
+
+import android.util.Log;
+import androidx.media3.common.util.UnstableApi;
+
+@UnstableApi
+public class Logger {
+
+    private String logTag;
+
+    // constructor
+    public Logger(String logTag) {
+        this.logTag = logTag;
+    }
+
+    public void setLogTag(String logTag) {
+        this.logTag = logTag;
+    }
+
+    public void error(String message) {
+        if (NativeAudio.debugEnabled) {
+            Log.e(logTag, message);
+        }
+    }
+
+    public void error(String message, Throwable throwable) {
+        if (NativeAudio.debugEnabled) {
+            Log.e(logTag, message, throwable);
+        }
+    }
+
+    public void warning(String message) {
+        if (NativeAudio.debugEnabled) {
+            Log.w(logTag, message);
+        }
+    }
+
+    public void info(String message) {
+        if (NativeAudio.debugEnabled) {
+            Log.i(logTag, message);
+        }
+    }
+
+    public void debug(String message) {
+        if (NativeAudio.debugEnabled) {
+            Log.d(logTag, message);
+        }
+    }
+
+    public void verbose(String message) {
+        if (NativeAudio.debugEnabled) {
+            Log.v(logTag, message);
+        }
+    }
+}