@capgo/native-audio 4.0.0

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

@@ -0,0 +1,178 @@
+package ee.forgr.audio;
+
+import android.content.res.AssetFileDescriptor;
+import android.media.AudioAttributes;
+import android.media.MediaPlayer;
+import android.os.Build;
+import android.os.SystemClock;
+import android.util.Log;
+import java.util.concurrent.Callable;
+
+public class AudioDispatcher
+    implements MediaPlayer.OnPreparedListener, MediaPlayer.OnCompletionListener, MediaPlayer.OnSeekCompleteListener {
+
+    private final String TAG = "AudioDispatcher";
+
+    private final int INVALID = 0;
+    private final int PREPARED = 1;
+    private final int PENDING_PLAY = 2;
+    private final int PLAYING = 3;
+    private final int PENDING_LOOP = 4;
+    private final int LOOPING = 5;
+    private final int PAUSE = 6;
+
+    private MediaPlayer mediaPlayer;
+    private int mediaState;
+    private AudioAsset owner;
+
+    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);
+        mediaPlayer.prepare();
+    }
+
+    public void setOwner(AudioAsset asset) {
+        owner = asset;
+    }
+
+    public double getDuration() {
+        return mediaPlayer.getDuration() / 1000.0;
+    }
+
+    public double getCurrentPosition() {
+        return mediaPlayer.getCurrentPosition() / 1000.0;
+    }
+
+    public void play(Double time, Callable<Void> callable) throws Exception {
+        invokePlay(time, false);
+    }
+
+    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);
+    }
+
+    public void loop() throws Exception {
+        mediaPlayer.setLooping(true);
+    }
+
+    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.dispatchComplete();
+                }
+            }
+        } 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, Boolean loop) {
+        try {
+            boolean playing = mediaPlayer.isPlaying();
+
+            if (playing) {
+                mediaPlayer.pause();
+                mediaPlayer.setLooping(loop);
+                mediaState = PENDING_PLAY;
+                seek(time);
+            } else {
+                if (mediaState == PREPARED) {
+                    mediaState = (loop ? PENDING_LOOP : PENDING_PLAY);
+                    onPrepared(mediaPlayer);
+                    seek(time);
+                } else {
+                    mediaState = (loop ? PENDING_LOOP : PENDING_PLAY);
+                    mediaPlayer.setLooping(loop);
+                    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() throws Exception {
+        return mediaPlayer.isPlaying();
+    }
+}

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

@@ -0,0 +1,18 @@
+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_FADE_MUSIC = "fade";
+    public static final String OPT_FOCUS_AUDIO = "focus";
+    public static final String VOLUME = "volume";
+    public static final String AUDIO_CHANNEL_NUM = "audioChannelNum";
+    public static final String LOOP = "loop";
+}

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

@@ -0,0 +1,471 @@
+package ee.forgr.audio;
+
+import static ee.forgr.audio.Constant.ASSET_ID;
+import static ee.forgr.audio.Constant.ASSET_PATH;
+import static ee.forgr.audio.Constant.AUDIO_CHANNEL_NUM;
+import static ee.forgr.audio.Constant.ERROR_ASSET_NOT_LOADED;
+import static ee.forgr.audio.Constant.ERROR_ASSET_PATH_MISSING;
+import static ee.forgr.audio.Constant.ERROR_AUDIO_ASSET_MISSING;
+import static ee.forgr.audio.Constant.ERROR_AUDIO_EXISTS;
+import static ee.forgr.audio.Constant.ERROR_AUDIO_ID_MISSING;
+import static ee.forgr.audio.Constant.LOOP;
+import static ee.forgr.audio.Constant.OPT_FADE_MUSIC;
+import static ee.forgr.audio.Constant.OPT_FOCUS_AUDIO;
+import static ee.forgr.audio.Constant.VOLUME;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.res.AssetFileDescriptor;
+import android.content.res.AssetManager;
+import android.media.AudioManager;
+import android.os.ParcelFileDescriptor;
+import android.util.Log;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import java.io.File;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.concurrent.Callable;
+
+@CapacitorPlugin(
+    permissions = {
+        @Permission(strings = { Manifest.permission.MODIFY_AUDIO_SETTINGS }),
+        @Permission(strings = { Manifest.permission.WRITE_EXTERNAL_STORAGE }),
+        @Permission(strings = { Manifest.permission.READ_PHONE_STATE })
+    }
+)
+public class NativeAudio extends Plugin implements AudioManager.OnAudioFocusChangeListener {
+
+    public static final String TAG = "NativeAudio";
+
+    private static HashMap<String, AudioAsset> audioAssetList;
+    private static ArrayList<AudioAsset> resumeList;
+    private boolean fadeMusic = false;
+    private AudioManager audioManager;
+
+    @Override
+    public void load() {
+        super.load();
+
+        this.audioManager = (AudioManager) getBridge().getActivity().getSystemService(Context.AUDIO_SERVICE);
+    }
+
+    @Override
+    public void onAudioFocusChange(int focusChange) {
+        if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT) {} else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {} else if (
+            focusChange == AudioManager.AUDIOFOCUS_LOSS
+        ) {}
+    }
+
+    @Override
+    protected void handleOnPause() {
+        super.handleOnPause();
+
+        try {
+            if (audioAssetList != null) {
+                for (HashMap.Entry<String, AudioAsset> entry : audioAssetList.entrySet()) {
+                    AudioAsset audio = entry.getValue();
+
+                    if (audio != null) {
+                        boolean wasPlaying = audio.pause();
+
+                        if (wasPlaying) {
+                            resumeList.add(audio);
+                        }
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            Log.d(TAG, "Exception caught while listening for handleOnPause: " + ex.getLocalizedMessage());
+        }
+    }
+
+    @Override
+    protected void handleOnResume() {
+        super.handleOnResume();
+
+        try {
+            if (resumeList != null) {
+                while (!resumeList.isEmpty()) {
+                    AudioAsset audio = resumeList.remove(0);
+
+                    if (audio != null) {
+                        audio.resume();
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            Log.d(TAG, "Exception caught while listening for handleOnResume: " + ex.getLocalizedMessage());
+        }
+    }
+
+    @PluginMethod
+    public void configure(PluginCall call) {
+        initSoundPool();
+
+        if (call.hasOption(OPT_FADE_MUSIC)) this.fadeMusic = call.getBoolean(OPT_FADE_MUSIC);
+
+        if (call.hasOption(OPT_FOCUS_AUDIO) && this.audioManager != null) {
+            if (call.getBoolean(OPT_FOCUS_AUDIO)) {
+                this.audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN);
+            } else {
+                this.audioManager.abandonAudioFocus(this);
+            }
+        }
+    }
+
+    @PluginMethod
+    public void preload(final PluginCall call) {
+        new Thread(
+            new Runnable() {
+                @Override
+                public void run() {
+                    preloadAsset(call);
+                }
+            }
+        )
+            .start();
+    }
+
+    @PluginMethod
+    public void play(final PluginCall call) {
+        getBridge()
+            .getActivity()
+            .runOnUiThread(
+                new Runnable() {
+                    @Override
+                    public void run() {
+                        playOrLoop("play", call);
+                    }
+                }
+            );
+    }
+
+    @PluginMethod
+    public void getCurrentTime(final PluginCall call) {
+        try {
+            initSoundPool();
+
+            String audioId = call.getString(ASSET_ID);
+
+            if (!isStringValid(audioId)) {
+                call.reject(ERROR_AUDIO_ID_MISSING + " - " + audioId);
+                return;
+            }
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    call.resolve(new JSObject().put("currentTime", asset.getCurrentPosition()));
+                }
+            } else {
+                call.reject(ERROR_AUDIO_ASSET_MISSING + " - " + audioId);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void getDuration(final PluginCall call) {
+        try {
+            initSoundPool();
+
+            String audioId = call.getString(ASSET_ID);
+
+            if (!isStringValid(audioId)) {
+                call.reject(ERROR_AUDIO_ID_MISSING + " - " + audioId);
+                return;
+            }
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    call.resolve(new JSObject().put("duration", asset.getDuration()));
+                }
+            } else {
+                call.reject(ERROR_AUDIO_ASSET_MISSING + " - " + audioId);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void loop(final PluginCall call) {
+        getBridge()
+            .getActivity()
+            .runOnUiThread(
+                new Runnable() {
+                    @Override
+                    public void run() {
+                        playOrLoop("loop", call);
+                    }
+                }
+            );
+    }
+
+    @PluginMethod
+    public void pause(PluginCall call) {
+        try {
+            initSoundPool();
+            String audioId = call.getString(ASSET_ID);
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    boolean wasPlaying = asset.pause();
+
+                    if (wasPlaying) {
+                        resumeList.add(asset);
+                    }
+                }
+            } else {
+                call.reject(ERROR_ASSET_NOT_LOADED + " - " + audioId);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void resume(PluginCall call) {
+        try {
+            initSoundPool();
+            String audioId = call.getString(ASSET_ID);
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    asset.resume();
+                    resumeList.add(asset);
+                }
+            } else {
+                call.reject(ERROR_ASSET_NOT_LOADED + " - " + audioId);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void stop(PluginCall call) {
+        try {
+            initSoundPool();
+            String audioId = call.getString(ASSET_ID);
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    asset.stop();
+                }
+            } else {
+                call.reject(ERROR_ASSET_NOT_LOADED + " - " + audioId);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void unload(PluginCall call) {
+        try {
+            initSoundPool();
+            new JSObject();
+            JSObject status;
+
+            if (isStringValid(call.getString(ASSET_ID))) {
+                String audioId = call.getString(ASSET_ID);
+
+                if (audioAssetList.containsKey(audioId)) {
+                    AudioAsset asset = audioAssetList.get(audioId);
+                    if (asset != null) {
+                        asset.unload();
+                        audioAssetList.remove(audioId);
+
+                        status = new JSObject();
+                        status.put("status", "OK");
+                        call.resolve(status);
+                    } else {
+                        status = new JSObject();
+                        status.put("status", false);
+                        call.resolve(status);
+                    }
+                } else {
+                    status = new JSObject();
+                    status.put("status", ERROR_AUDIO_ASSET_MISSING + " - " + audioId);
+                    call.resolve(status);
+                }
+            } else {
+                status = new JSObject();
+                status.put("status", ERROR_AUDIO_ID_MISSING);
+                call.resolve(status);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void setVolume(PluginCall call) {
+        try {
+            initSoundPool();
+
+            String audioId = call.getString(ASSET_ID);
+            float volume = call.getFloat(VOLUME);
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    asset.setVolume(volume);
+                }
+            } else {
+                call.reject(ERROR_AUDIO_ASSET_MISSING);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void isPlaying(final PluginCall call) {
+        try {
+            initSoundPool();
+
+            String audioId = call.getString(ASSET_ID);
+
+            if (!isStringValid(audioId)) {
+                call.reject(ERROR_AUDIO_ID_MISSING + " - " + audioId);
+                return;
+            }
+
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (asset != null) {
+                    call.resolve(new JSObject().put("isPlaying", asset.isPlaying()));
+                }
+            } else {
+                call.reject(ERROR_AUDIO_ASSET_MISSING + " - " + audioId);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    public void dispatchComplete(String assetId) {
+        JSObject ret = new JSObject();
+        ret.put("assetId", assetId);
+        notifyListeners("complete", ret);
+    }
+
+    private void preloadAsset(PluginCall call) {
+        double volume = 1.0;
+        int audioChannelNum = 1;
+
+        try {
+            initSoundPool();
+
+            String audioId = call.getString(ASSET_ID);
+
+            boolean isUrl = 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);
+
+                if (!isStringValid(assetPath)) {
+                    call.reject(ERROR_ASSET_PATH_MISSING + " - " + audioId + " - " + assetPath);
+                    return;
+                }
+
+                String fullPath = assetPath; //"raw/".concat(assetPath);
+
+                if (call.getDouble(VOLUME) == null) {
+                    volume = 1.0;
+                } else {
+                    volume = call.getDouble(VOLUME, 0.5);
+                }
+
+                if (call.getInt(AUDIO_CHANNEL_NUM) == null) {
+                    audioChannelNum = 1;
+                } else {
+                    audioChannelNum = call.getInt(AUDIO_CHANNEL_NUM);
+                }
+
+                AssetFileDescriptor assetFileDescriptor;
+                if (isUrl) {
+                    File f = new File(new URI(fullPath));
+                    ParcelFileDescriptor p = ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY);
+                    assetFileDescriptor = new AssetFileDescriptor(p, 0, -1);
+                } else {
+                    Context ctx = getBridge().getActivity().getApplicationContext();
+                    AssetManager am = ctx.getResources().getAssets();
+                    assetFileDescriptor = am.openFd(fullPath);
+                }
+
+                AudioAsset asset = new AudioAsset(this, audioId, assetFileDescriptor, audioChannelNum, (float) volume);
+                audioAssetList.put(audioId, asset);
+
+                JSObject status = new JSObject();
+                status.put("STATUS", "OK");
+                call.resolve(status);
+            } else {
+                call.reject(ERROR_AUDIO_EXISTS);
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    private void playOrLoop(String action, final PluginCall call) {
+        try {
+            initSoundPool();
+
+            final String audioId = call.getString(ASSET_ID);
+            final Double time = call.getDouble("time", 0.0);
+            if (audioAssetList.containsKey(audioId)) {
+                AudioAsset asset = audioAssetList.get(audioId);
+                if (LOOP.equals(action) && asset != null) {
+                    asset.loop();
+                } else if (asset != null) {
+                    asset.play(
+                        time,
+                        new Callable<Void>() {
+                            @Override
+                            public Void call() throws Exception {
+                                call.resolve(new JSObject().put(ASSET_ID, audioId));
+
+                                return null;
+                            }
+                        }
+                    );
+                }
+            }
+        } catch (Exception ex) {
+            call.reject(ex.getMessage());
+        }
+    }
+
+    private void initSoundPool() {
+        if (audioAssetList == null) {
+            audioAssetList = new HashMap<>();
+        }
+
+        if (resumeList == null) {
+            resumeList = new ArrayList<>();
+        }
+    }
+
+    private boolean isStringValid(String value) {
+        return (value != null && !value.isEmpty() && !value.equals("null"));
+    }
+}

package/android/src/main/res/layout/bridge_layout_main.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="com.getcapacitor.BridgeActivity"
+    >
+
+    <WebView
+        android:id="@+id/webview"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>

package/android/src/main/res/values/colors.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+</resources>

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="my_string">Just a simple string</string>
+</resources>

package/android/src/main/res/values/styles.xml

@@ -0,0 +1,3 @@
+<resources>
+
+</resources>