@capgo/capacitor-native-audio 8.4.3

package/android/build.gradle

@@ -0,0 +1,89 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0'
+
+    // Read HLS configuration from gradle.properties (set by hook script)
+    // Default to 'true' for backward compatibility
+    includeHls = project.findProperty('nativeAudio.hls.include') ?: 'true'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "ee.forgr.audio.nativeaudio"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+
+    // Exclude StreamAudioAsset when HLS is disabled
+    // StreamAudioAsset depends on HlsMediaSource which is only available with media3-exoplayer-hls
+    sourceSets {
+        main {
+            if (includeHls != 'true') {
+                java.exclude '**/StreamAudioAsset.java'
+            }
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+    implementation 'androidx.media3:media3-exoplayer:1.10.0'
+
+    // HLS (m3u8) streaming support - optional dependency
+    // When disabled, reduces APK size by ~4MB
+    // Configure via capacitor.config.ts: plugins.NativeAudio.hls = false
+    if (includeHls == 'true') {
+        implementation 'androidx.media3:media3-exoplayer-hls:1.10.0'
+    }
+
+    implementation 'androidx.media3:media3-session:1.10.0'
+    implementation 'androidx.media3:media3-transformer:1.10.0'
+    implementation 'androidx.media3:media3-ui:1.10.0'
+    implementation 'androidx.media3:media3-database:1.10.0'
+    implementation 'androidx.media3:media3-common:1.10.0'
+    // Media notification support
+    implementation 'androidx.media:media:1.7.1'
+    implementation 'androidx.core:core:1.13.1'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+</manifest>

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

@@ -0,0 +1,611 @@
+package ee.forgr.audio;
+
+import android.content.res.AssetFileDescriptor;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import androidx.media3.common.util.UnstableApi;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+@UnstableApi
+public class AudioAsset implements AutoCloseable {
+
+    public static final double DEFAULT_FADE_DURATION_MS = 1000.0;
+
+    private static final String TAG = "AudioAsset";
+    protected static final Logger logger = new Logger(TAG);
+
+    private final ArrayList<AudioDispatcher> audioList;
+    protected int playIndex = 0;
+    protected final NativeAudio owner;
+    protected AudioCompletionListener completionListener;
+    protected String assetId;
+    protected Handler currentTimeHandler;
+    protected Runnable currentTimeRunnable;
+    protected static final int FADE_DELAY_MS = 80;
+
+    protected ScheduledExecutorService fadeExecutor;
+    protected ScheduledFuture<?> fadeTask;
+
+    protected Map<String, Boolean> dispatchedCompleteMap = new ConcurrentHashMap<>();
+
+    protected enum FadeState {
+        NONE,
+        FADE_IN,
+        FADE_OUT,
+        FADE_TO
+    }
+
+    protected FadeState fadeState = FadeState.NONE;
+
+    protected final float zeroVolume = 0.001f;
+    protected final float maxVolume = 1.0f;
+
+    AudioAsset(NativeAudio owner, String assetId, AssetFileDescriptor assetFileDescriptor, int audioChannelNum, float volume)
+        throws Exception {
+        audioList = new ArrayList<>();
+        this.owner = owner;
+        this.assetId = assetId;
+        this.fadeExecutor = Executors.newSingleThreadScheduledExecutor();
+
+        if (audioChannelNum < 0) {
+            audioChannelNum = 1;
+        }
+
+        for (int x = 0; x < audioChannelNum; x++) {
+            AudioDispatcher audioDispatcher = new AudioDispatcher(assetFileDescriptor, volume);
+            audioList.add(audioDispatcher);
+            if (audioChannelNum == 1) audioDispatcher.setOwner(this);
+        }
+    }
+
+    public void dispatchComplete() {
+        if (dispatchedCompleteMap.getOrDefault(this.assetId, false)) {
+            return;
+        }
+        this.owner.dispatchComplete(this.assetId);
+        dispatchedCompleteMap.put(this.assetId, true);
+    }
+
+    public void play(double time, float volume) throws Exception {
+        if (audioList.isEmpty() || playIndex < 0 || playIndex >= audioList.size()) {
+            throw new Exception("AudioDispatcher is null or playIndex out of bounds");
+        }
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            cancelFade();
+            audio.play(time);
+            audio.setVolume(volume);
+            playIndex++;
+            playIndex = playIndex % audioList.size();
+            logger.debug("Starting timer from play"); // Debug log
+            startCurrentTimeUpdates(); // Make sure this is called
+        } else {
+            throw new Exception("AudioDispatcher is null");
+        }
+    }
+
+    public void play(double time) throws Exception {
+        play(time, 1.0f);
+    }
+
+    public double getDuration() {
+        if (audioList.size() != 1 || playIndex < 0 || playIndex >= audioList.size()) return 0;
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            return audio.getDuration();
+        }
+        return 0;
+    }
+
+    public void setCurrentPosition(double time) {
+        if (audioList.size() != 1 || playIndex < 0 || playIndex >= audioList.size()) return;
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            audio.setCurrentPosition(time);
+        }
+    }
+
+    public double getCurrentPosition() {
+        if (audioList.size() != 1 || playIndex < 0 || playIndex >= audioList.size()) return 0;
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            return audio.getCurrentPosition();
+        }
+        return 0;
+    }
+
+    public boolean pause() throws Exception {
+        stopCurrentTimeUpdates(); // Stop updates when pausing
+        boolean wasPlaying = false;
+
+        for (int x = 0; x < audioList.size(); x++) {
+            AudioDispatcher audio = audioList.get(x);
+            if (audio == null) {
+                continue;
+            }
+            cancelFade();
+            wasPlaying |= audio.pause();
+        }
+
+        return wasPlaying;
+    }
+
+    public void resume() throws Exception {
+        if (!audioList.isEmpty()) {
+            AudioDispatcher audio = audioList.get(0);
+            if (audio != null) {
+                audio.resume();
+                logger.debug("Starting timer from resume"); // Debug log
+                startCurrentTimeUpdates(); // Make sure this is called
+            } else {
+                throw new Exception("AudioDispatcher is null");
+            }
+        }
+    }
+
+    public void stop() throws Exception {
+        stopCurrentTimeUpdates(); // Stop updates when stopping
+        dispatchComplete();
+        for (int x = 0; x < audioList.size(); x++) {
+            AudioDispatcher audio = audioList.get(x);
+
+            if (audio != null) {
+                cancelFade();
+                audio.stop();
+            } else {
+                throw new Exception("AudioDispatcher is null");
+            }
+        }
+    }
+
+    public void loop() throws Exception {
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            audio.loop();
+            playIndex++;
+            playIndex = playIndex % audioList.size();
+            startCurrentTimeUpdates(); // Add timer start
+        } else {
+            throw new Exception("AudioDispatcher is null");
+        }
+    }
+
+    public void unload() throws Exception {
+        this.stop();
+
+        for (int x = 0; x < audioList.size(); x++) {
+            AudioDispatcher audio = audioList.get(x);
+
+            if (audio != null) {
+                audio.unload();
+            } else {
+                throw new Exception("AudioDispatcher is null");
+            }
+        }
+
+        audioList.clear();
+        stopCurrentTimeUpdates();
+        close();
+    }
+
+    public void setVolume(float volume, double duration) throws Exception {
+        for (int x = 0; x < audioList.size(); x++) {
+            AudioDispatcher audio = audioList.get(x);
+
+            cancelFade();
+            if (audio != null) {
+                if (isPlaying() && duration > 0) {
+                    fadeTo(audio, duration, volume);
+                } else {
+                    audio.setVolume(volume);
+                }
+            } else {
+                throw new Exception("AudioDispatcher is null");
+            }
+        }
+    }
+
+    public void setVolume(float volume) throws Exception {
+        setVolume(volume, 0);
+    }
+
+    public float getVolume() throws Exception {
+        if (audioList.size() != 1 || playIndex < 0 || playIndex >= audioList.size()) return 0;
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            return audio.getVolume();
+        }
+        throw new Exception("AudioDispatcher is null");
+    }
+
+    public void setRate(float rate) throws Exception {
+        for (int x = 0; x < audioList.size(); x++) {
+            AudioDispatcher audio = audioList.get(x);
+            if (audio != null) {
+                audio.setRate(rate);
+            }
+        }
+    }
+
+    public boolean isPlaying() throws Exception {
+        for (AudioDispatcher ad : audioList) {
+            if (ad != null && ad.isPlaying()) return true;
+        }
+        return false;
+    }
+
+    public void setCompletionListener(AudioCompletionListener listener) {
+        this.completionListener = listener;
+    }
+
+    protected void notifyCompletion() {
+        if (completionListener != null) {
+            completionListener.onCompletion(this.assetId);
+        }
+    }
+
+    protected String getAssetId() {
+        return assetId;
+    }
+
+    public void setCurrentTime(double time) throws Exception {
+        if (owner == null || owner.getActivity() == null) return;
+        owner
+            .getActivity()
+            .runOnUiThread(
+                new Runnable() {
+                    @Override
+                    public void run() {
+                        if (audioList.size() != 1 || playIndex < 0 || playIndex >= audioList.size()) {
+                            return;
+                        }
+                        AudioDispatcher audio = audioList.get(playIndex);
+                        if (audio != null) {
+                            audio.setCurrentPosition(time);
+                        }
+                    }
+                }
+            );
+    }
+
+    protected void startCurrentTimeUpdates() {
+        logger.debug("Starting timer updates");
+        if (currentTimeHandler == null) {
+            currentTimeHandler = new Handler(Looper.getMainLooper());
+        }
+        dispatchedCompleteMap.put(assetId, false);
+        currentTimeHandler.postDelayed(
+            new Runnable() {
+                @Override
+                public void run() {
+                    startTimeUpdateLoop();
+                }
+            },
+            100
+        );
+    }
+
+    private void startTimeUpdateLoop() {
+        currentTimeRunnable = new Runnable() {
+            @Override
+            public void run() {
+                AudioDispatcher audio = null;
+                try {
+                    if (audioList.isEmpty() || playIndex < 0 || playIndex >= audioList.size()) {
+                        logger.verbose("Audio dispatcher does not exist at index " + playIndex);
+                        return;
+                    }
+                    audio = audioList.get(playIndex);
+                } catch (Exception e) {
+                    logger.verbose("Audio dispatcher does not exist at index " + playIndex);
+                }
+                if (audio == null) {
+                    logger.debug("Audio dispatcher does not exist - aborting timer update");
+                    return;
+                }
+                try {
+                    if (audio != null && audio.isPlaying()) {
+                        double currentTime = getCurrentPosition();
+                        logger.verbose("Play timer update: currentTime = " + currentTime);
+                        if (owner != null) owner.notifyCurrentTime(assetId, currentTime);
+                        currentTimeHandler.postDelayed(this, 100);
+                    } else {
+                        logger.debug("Audio is not not playing");
+                        stopCurrentTimeUpdates();
+                        if (audio.isPaused()) {
+                            logger.verbose("Audio is paused");
+                        } else {
+                            logger.verbose("Audio is not paused - dispatching complete");
+                            dispatchComplete();
+                        }
+                    }
+                } catch (Exception e) {
+                    logger.error("Error getting current time", e);
+                    stopCurrentTimeUpdates();
+                }
+            }
+        };
+        try {
+            if (currentTimeHandler == null) {
+                currentTimeHandler = new Handler(Looper.getMainLooper());
+            }
+            currentTimeHandler.post(currentTimeRunnable);
+        } catch (Exception e) {
+            logger.error("Error starting current time updates", e);
+        }
+    }
+
+    void stopCurrentTimeUpdates() {
+        logger.verbose("Stopping play timer updates");
+        if (currentTimeHandler != null && currentTimeRunnable != null) {
+            currentTimeHandler.removeCallbacks(currentTimeRunnable);
+            currentTimeHandler = null;
+            currentTimeRunnable = null;
+        }
+    }
+
+    public void playWithFadeIn(double time, float volume, double fadeInDurationMs) throws Exception {
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null) {
+            audio.setVolume(0);
+            audio.play(time);
+            fadeIn(audio, fadeInDurationMs, volume);
+            startCurrentTimeUpdates();
+        }
+    }
+
+    public void playWithFade(double time) throws Exception {
+        playWithFadeIn(time, 1.0f, DEFAULT_FADE_DURATION_MS);
+    }
+
+    private void fadeIn(final AudioDispatcher audio, double fadeInDurationMs, float targetVolume) {
+        cancelFade();
+        fadeState = FadeState.FADE_IN;
+
+        final int steps = Math.max(1, (int) (fadeInDurationMs / FADE_DELAY_MS));
+        final float fadeStep = targetVolume / steps;
+
+        Log.d(
+            TAG,
+            "Beginning fade in at time " +
+                getCurrentPosition() +
+                " over " +
+                (fadeInDurationMs / 1000.0) +
+                "s to target volume " +
+                targetVolume +
+                " in " +
+                steps +
+                " steps (step duration: " +
+                (FADE_DELAY_MS / 1000.0) +
+                "s"
+        );
+
+        fadeTask = fadeExecutor.scheduleWithFixedDelay(
+            new Runnable() {
+                float currentVolume = 0;
+
+                @Override
+                public void run() {
+                    if (fadeState != FadeState.FADE_IN || currentVolume >= targetVolume) {
+                        fadeState = FadeState.NONE;
+                        cancelFade();
+                        logger.debug("Fade in complete at time " + getCurrentPosition());
+                        return;
+                    }
+                    final float previousCurrentVolume = currentVolume;
+                    currentVolume += fadeStep;
+                    try {
+                        final float resolvedTargetVolume = Math.min(Math.max(currentVolume, 0), targetVolume);
+                        Log.v(
+                            TAG,
+                            "Fade in step: from " + previousCurrentVolume + " to " + currentVolume + " to target " + resolvedTargetVolume
+                        );
+                        if (audio != null) audio.setVolume(resolvedTargetVolume);
+                    } catch (Exception e) {
+                        logger.error("Error during fade in", e);
+                        cancelFade();
+                    }
+                }
+            },
+            0,
+            FADE_DELAY_MS,
+            TimeUnit.MILLISECONDS
+        );
+    }
+
+    public void stopWithFade(double fadeOutDurationMs, boolean toPause) throws Exception {
+        AudioDispatcher audio = audioList.get(playIndex);
+        if (audio != null && audio.isPlaying()) {
+            cancelFade();
+            fadeOut(audio, fadeOutDurationMs, toPause);
+        } else if (!toPause) {
+            stop();
+        }
+    }
+
+    public void stopWithFade() throws Exception {
+        stopWithFade(DEFAULT_FADE_DURATION_MS, false);
+    }
+
+    private void fadeOut(final AudioDispatcher audio, double fadeOutDurationMs, boolean toPause) {
+        cancelFade();
+        fadeState = FadeState.FADE_OUT;
+
+        if (audio == null) return;
+
+        final int steps = Math.max(1, (int) (fadeOutDurationMs / FADE_DELAY_MS));
+        final float initialVolume = audio.getVolume();
+        final float fadeStep = initialVolume / steps;
+
+        Log.d(
+            TAG,
+            "Beginning fade out from volume " +
+                initialVolume +
+                " at time " +
+                getCurrentPosition() +
+                " over " +
+                (fadeOutDurationMs / 1000.0) +
+                "s in " +
+                steps +
+                " steps (step duration: " +
+                (FADE_DELAY_MS / 1000.0) +
+                "s)"
+        );
+
+        fadeTask = fadeExecutor.scheduleWithFixedDelay(
+            new Runnable() {
+                float currentVolume = initialVolume;
+
+                @Override
+                public void run() {
+                    try {
+                        if (fadeState != FadeState.FADE_OUT || currentVolume <= 0) {
+                            fadeState = FadeState.NONE;
+                            if (toPause) {
+                                logger.verbose("Faded out to pause audio at time " + getCurrentPosition());
+                                audio.pause();
+                            } else {
+                                logger.verbose("Faded out to stop at time " + getCurrentPosition());
+                                stop();
+                            }
+                            cancelFade();
+                            logger.debug("Fade out complete at time " + getCurrentPosition());
+                            return;
+                        }
+                        final float previousCurrentVolume = currentVolume;
+                        currentVolume -= fadeStep;
+
+                        final float thisTargetVolume = Math.max(currentVolume, 0);
+                        Log.v(
+                            TAG,
+                            "Fade out step: from " + previousCurrentVolume + " to " + currentVolume + " to target " + thisTargetVolume
+                        );
+                        if (audio != null) audio.setVolume(thisTargetVolume);
+                    } catch (Exception e) {
+                        logger.error("Error during fade out", e);
+                        cancelFade();
+                    }
+                }
+            },
+            0,
+            FADE_DELAY_MS,
+            TimeUnit.MILLISECONDS
+        );
+    }
+
+    protected void fadeTo(final AudioDispatcher audio, double fadeDurationMs, float targetVolume) {
+        cancelFade();
+        fadeState = FadeState.FADE_TO;
+
+        if (audio == null) return;
+
+        final int steps = Math.max(1, (int) (fadeDurationMs / FADE_DELAY_MS));
+        final float minVolume = zeroVolume;
+        final float initialVolume = Math.max(audio.getVolume(), minVolume);
+        final float finalTargetVolume = Math.max(targetVolume, minVolume);
+
+        // Clamp values to avoid overflow/underflow and invalid pow inputs
+        final float safeInitialVolume = Math.max(initialVolume, minVolume);
+        final float safeFinalTargetVolume = Math.max(finalTargetVolume, minVolume);
+
+        double ratio;
+        if (steps <= 0 || safeInitialVolume <= 0f || safeFinalTargetVolume <= 0f) {
+            ratio = 1.0; // No fade or invalid, just set directly
+        } else if (safeInitialVolume == safeFinalTargetVolume) {
+            ratio = 1.0;
+        } else {
+            ratio = Math.pow(safeFinalTargetVolume / safeInitialVolume, 1.0 / steps);
+            // Clamp ratio to reasonable bounds to avoid overflow
+            if (Double.isNaN(ratio) || Double.isInfinite(ratio) || ratio <= 0.0) {
+                ratio = 1.0;
+            }
+        }
+
+        Log.d(
+            TAG,
+            "Beginning exponential fade from volume " +
+                initialVolume +
+                " to " +
+                finalTargetVolume +
+                " over " +
+                (fadeDurationMs / 1000.0) +
+                "s in " +
+                steps +
+                " steps (step duration: " +
+                (FADE_DELAY_MS / 1000.0) +
+                "s, ratio: " +
+                ratio +
+                ")"
+        );
+
+        double finalRatio = ratio;
+        fadeTask = fadeExecutor.scheduleWithFixedDelay(
+            new Runnable() {
+                int currentStep = 0;
+                float currentVolume = initialVolume;
+
+                @Override
+                public void run() {
+                    if ((audio != null && fadeState != FadeState.FADE_TO) || !audio.isPlaying() || currentStep >= steps) {
+                        fadeState = FadeState.NONE;
+                        cancelFade();
+                        logger.debug("Fade to complete at time " + getCurrentPosition());
+                        return;
+                    }
+
+                    try {
+                        if (finalRatio == 1.0) {
+                            currentVolume = safeFinalTargetVolume;
+                        } else {
+                            currentVolume *= (float) finalRatio;
+                        }
+                        currentVolume = Math.min(Math.max(currentVolume, minVolume), maxVolume); // Clamp between minVolume and maxVolume
+                        if (audio != null) audio.setVolume(currentVolume);
+                        logger.verbose("Fade to step " + currentStep + ": volume set to " + currentVolume);
+                        currentStep++;
+                    } catch (Exception e) {
+                        logger.error("Error during fade to", e);
+                        cancelFade();
+                    }
+                }
+            },
+            0,
+            FADE_DELAY_MS,
+            TimeUnit.MILLISECONDS
+        );
+    }
+
+    /**
+     * Cancels the fade task if it is running.
+     */
+    protected void cancelFade() {
+        if (fadeTask != null && !fadeTask.isCancelled()) {
+            fadeTask.cancel(true);
+        }
+        fadeState = FadeState.NONE;
+        fadeTask = null;
+    }
+
+    @Override
+    public void close() {
+        if (fadeExecutor != null && !fadeExecutor.isShutdown()) {
+            fadeExecutor.shutdown();
+        }
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            close();
+        } finally {
+            super.finalize();
+        }
+    }
+}