@capawesome/capacitor-volume 0.0.1

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/Volume.java

@@ -0,0 +1,158 @@
+package io.capawesome.capacitorjs.plugins.volume;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.media.AudioManager;
+import android.os.Handler;
+import android.os.Looper;
+import android.provider.Settings;
+import android.view.KeyEvent;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import io.capawesome.capacitorjs.plugins.volume.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.events.VolumeButtonPressedEvent;
+import io.capawesome.capacitorjs.plugins.volume.classes.events.VolumeChangeEvent;
+import io.capawesome.capacitorjs.plugins.volume.classes.options.GetVolumeOptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.options.SetVolumeOptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.options.StartWatchingOptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.results.GetVolumeResult;
+import io.capawesome.capacitorjs.plugins.volume.classes.results.IsWatchingResult;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.NonEmptyResultCallback;
+
+public class Volume {
+
+    private static final String DIRECTION_DOWN = "down";
+    private static final String DIRECTION_UP = "up";
+
+    @NonNull
+    private final AudioManager audioManager;
+
+    private int lastVolume = -1;
+
+    @NonNull
+    private final View.OnKeyListener onKeyListener = (view, keyCode, event) -> handleKeyEvent(keyCode, event);
+
+    @NonNull
+    private final VolumePlugin plugin;
+
+    private boolean suppressVolumeChange = false;
+
+    @Nullable
+    private ContentObserver volumeObserver;
+
+    private boolean watching = false;
+
+    public Volume(@NonNull VolumePlugin plugin) {
+        this.plugin = plugin;
+        this.audioManager = (AudioManager) plugin.getContext().getSystemService(Context.AUDIO_SERVICE);
+    }
+
+    public void getVolume(@NonNull GetVolumeOptions options, @NonNull NonEmptyResultCallback<GetVolumeResult> callback) {
+        double volume = getNormalizedVolume(options.getStreamType());
+        callback.success(new GetVolumeResult(volume));
+    }
+
+    public void isWatching(@NonNull NonEmptyResultCallback<IsWatchingResult> callback) {
+        callback.success(new IsWatchingResult(watching));
+    }
+
+    public void setVolume(@NonNull SetVolumeOptions options, @NonNull EmptyCallback callback) {
+        int streamType = options.getStreamType();
+        int maxVolume = audioManager.getStreamMaxVolume(streamType);
+        int volume = Math.round(options.getVolume() * maxVolume);
+        try {
+            audioManager.setStreamVolume(streamType, volume, 0);
+        } catch (SecurityException exception) {
+            callback.error(CustomExceptions.DO_NOT_DISTURB_ACCESS_REQUIRED);
+            return;
+        }
+        callback.success();
+    }
+
+    public void startWatching(@NonNull StartWatchingOptions options, @NonNull EmptyCallback callback) {
+        if (watching) {
+            callback.success();
+            return;
+        }
+        suppressVolumeChange = options.isSuppressVolumeChange();
+        lastVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
+        registerVolumeObserver();
+        watching = true;
+        plugin
+            .getActivity()
+            .runOnUiThread(() -> {
+                View webView = plugin.getBridge().getWebView();
+                webView.setOnKeyListener(onKeyListener);
+                webView.requestFocus();
+                callback.success();
+            });
+    }
+
+    public void stopWatching(@Nullable EmptyCallback callback) {
+        if (!watching) {
+            if (callback != null) {
+                callback.success();
+            }
+            return;
+        }
+        unregisterVolumeObserver();
+        suppressVolumeChange = false;
+        watching = false;
+        plugin
+            .getActivity()
+            .runOnUiThread(() -> {
+                plugin.getBridge().getWebView().setOnKeyListener(null);
+                if (callback != null) {
+                    callback.success();
+                }
+            });
+    }
+
+    private double getNormalizedVolume(int streamType) {
+        int volume = audioManager.getStreamVolume(streamType);
+        int maxVolume = audioManager.getStreamMaxVolume(streamType);
+        return volume / (double) maxVolume;
+    }
+
+    private boolean handleKeyEvent(int keyCode, @NonNull KeyEvent event) {
+        if (keyCode != KeyEvent.KEYCODE_VOLUME_UP && keyCode != KeyEvent.KEYCODE_VOLUME_DOWN) {
+            return false;
+        }
+        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+            String direction = keyCode == KeyEvent.KEYCODE_VOLUME_UP ? DIRECTION_UP : DIRECTION_DOWN;
+            plugin.notifyVolumeButtonPressedListeners(new VolumeButtonPressedEvent(direction));
+        }
+        return suppressVolumeChange;
+    }
+
+    private void handleVolumeChanged() {
+        int volume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
+        if (volume == lastVolume) {
+            return;
+        }
+        lastVolume = volume;
+        int maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
+        plugin.notifyVolumeChangeListeners(new VolumeChangeEvent(volume / (double) maxVolume));
+    }
+
+    private void registerVolumeObserver() {
+        ContentObserver volumeObserver = new ContentObserver(new Handler(Looper.getMainLooper())) {
+            @Override
+            public void onChange(boolean selfChange) {
+                handleVolumeChanged();
+            }
+        };
+        plugin.getContext().getContentResolver().registerContentObserver(Settings.System.CONTENT_URI, true, volumeObserver);
+        this.volumeObserver = volumeObserver;
+    }
+
+    private void unregisterVolumeObserver() {
+        ContentObserver volumeObserver = this.volumeObserver;
+        if (volumeObserver != null) {
+            plugin.getContext().getContentResolver().unregisterContentObserver(volumeObserver);
+            this.volumeObserver = null;
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/VolumeHelper.java

@@ -0,0 +1,27 @@
+package io.capawesome.capacitorjs.plugins.volume;
+
+import android.media.AudioManager;
+import androidx.annotation.NonNull;
+import io.capawesome.capacitorjs.plugins.volume.classes.CustomExceptions;
+
+public class VolumeHelper {
+
+    public static int mapStreamToStreamType(@NonNull String stream) throws Exception {
+        switch (stream) {
+            case "alarm":
+                return AudioManager.STREAM_ALARM;
+            case "music":
+                return AudioManager.STREAM_MUSIC;
+            case "notification":
+                return AudioManager.STREAM_NOTIFICATION;
+            case "ring":
+                return AudioManager.STREAM_RING;
+            case "system":
+                return AudioManager.STREAM_SYSTEM;
+            case "voiceCall":
+                return AudioManager.STREAM_VOICE_CALL;
+            default:
+                throw CustomExceptions.STREAM_INVALID;
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/VolumePlugin.java

@@ -0,0 +1,178 @@
+package io.capawesome.capacitorjs.plugins.volume;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.volume.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.volume.classes.events.VolumeButtonPressedEvent;
+import io.capawesome.capacitorjs.plugins.volume.classes.events.VolumeChangeEvent;
+import io.capawesome.capacitorjs.plugins.volume.classes.options.GetVolumeOptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.options.SetVolumeOptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.options.StartWatchingOptions;
+import io.capawesome.capacitorjs.plugins.volume.classes.results.GetVolumeResult;
+import io.capawesome.capacitorjs.plugins.volume.classes.results.IsWatchingResult;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.Result;
+
+@CapacitorPlugin(name = "Volume")
+public class VolumePlugin extends Plugin {
+
+    public static final String EVENT_VOLUME_BUTTON_PRESSED = "volumeButtonPressed";
+    public static final String EVENT_VOLUME_CHANGE = "volumeChange";
+    public static final String TAG = "VolumePlugin";
+
+    private static final String ERROR_UNKNOWN_ERROR = "An unknown error occurred.";
+
+    private Volume implementation;
+
+    @PluginMethod
+    public void getVolume(PluginCall call) {
+        try {
+            GetVolumeOptions options = new GetVolumeOptions(call);
+            NonEmptyResultCallback<GetVolumeResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull GetVolumeResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.getVolume(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void isWatching(PluginCall call) {
+        try {
+            NonEmptyResultCallback<IsWatchingResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull IsWatchingResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.isWatching(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @Override
+    public void load() {
+        implementation = new Volume(this);
+    }
+
+    public void notifyVolumeButtonPressedListeners(@NonNull VolumeButtonPressedEvent event) {
+        notifyListeners(EVENT_VOLUME_BUTTON_PRESSED, event.toJSObject());
+    }
+
+    public void notifyVolumeChangeListeners(@NonNull VolumeChangeEvent event) {
+        notifyListeners(EVENT_VOLUME_CHANGE, event.toJSObject());
+    }
+
+    @PluginMethod
+    public void setVolume(PluginCall call) {
+        try {
+            SetVolumeOptions options = new SetVolumeOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.setVolume(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void startWatching(PluginCall call) {
+        try {
+            StartWatchingOptions options = new StartWatchingOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.startWatching(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void stopWatching(PluginCall call) {
+        try {
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.stopWatching(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        implementation.stopWatching(null);
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        String code = null;
+        if (exception instanceof CustomException) {
+            code = ((CustomException) exception).getCode();
+        }
+        Logger.error(TAG, message, exception);
+        call.reject(message, code);
+    }
+
+    private void resolveCall(@NonNull PluginCall call) {
+        call.resolve();
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @NonNull Result result) {
+        call.resolve(result.toJSObject());
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/CustomException.java

@@ -0,0 +1,20 @@
+package io.capawesome.capacitorjs.plugins.volume.classes;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class CustomException extends Exception {
+
+    @Nullable
+    private final String code;
+
+    public CustomException(@Nullable String code, @NonNull String message) {
+        super(message);
+        this.code = code;
+    }
+
+    @Nullable
+    public String getCode() {
+        return code;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/CustomExceptions.java

@@ -0,0 +1,12 @@
+package io.capawesome.capacitorjs.plugins.volume.classes;
+
+public class CustomExceptions {
+
+    public static final CustomException DO_NOT_DISTURB_ACCESS_REQUIRED = new CustomException(
+        "DO_NOT_DISTURB_ACCESS_REQUIRED",
+        "Do Not Disturb access is required to change the volume of this stream."
+    );
+    public static final CustomException STREAM_INVALID = new CustomException(null, "stream is invalid.");
+    public static final CustomException VOLUME_INVALID = new CustomException(null, "volume must be between 0 and 1.");
+    public static final CustomException VOLUME_MISSING = new CustomException(null, "volume must be provided.");
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/events/VolumeButtonPressedEvent.java

@@ -0,0 +1,23 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.events;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.Result;
+
+public class VolumeButtonPressedEvent implements Result {
+
+    @NonNull
+    private final String direction;
+
+    public VolumeButtonPressedEvent(@NonNull String direction) {
+        this.direction = direction;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("direction", direction);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/events/VolumeChangeEvent.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.events;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.Result;
+
+public class VolumeChangeEvent implements Result {
+
+    private final double volume;
+
+    public VolumeChangeEvent(double volume) {
+        this.volume = volume;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("volume", volume);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/options/GetVolumeOptions.java

@@ -0,0 +1,23 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.volume.VolumeHelper;
+
+public class GetVolumeOptions {
+
+    private final int streamType;
+
+    public GetVolumeOptions(@NonNull PluginCall call) throws Exception {
+        this.streamType = GetVolumeOptions.getStreamTypeFromCall(call);
+    }
+
+    public int getStreamType() {
+        return streamType;
+    }
+
+    private static int getStreamTypeFromCall(@NonNull PluginCall call) throws Exception {
+        String stream = call.getString("stream", "music");
+        return VolumeHelper.mapStreamToStreamType(stream);
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/options/SetVolumeOptions.java

@@ -0,0 +1,41 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+import io.capawesome.capacitorjs.plugins.volume.VolumeHelper;
+import io.capawesome.capacitorjs.plugins.volume.classes.CustomExceptions;
+
+public class SetVolumeOptions {
+
+    private final int streamType;
+    private final float volume;
+
+    public SetVolumeOptions(@NonNull PluginCall call) throws Exception {
+        this.streamType = SetVolumeOptions.getStreamTypeFromCall(call);
+        this.volume = SetVolumeOptions.getVolumeFromCall(call);
+    }
+
+    public int getStreamType() {
+        return streamType;
+    }
+
+    public float getVolume() {
+        return volume;
+    }
+
+    private static int getStreamTypeFromCall(@NonNull PluginCall call) throws Exception {
+        String stream = call.getString("stream", "music");
+        return VolumeHelper.mapStreamToStreamType(stream);
+    }
+
+    private static float getVolumeFromCall(@NonNull PluginCall call) throws Exception {
+        Float volume = call.getFloat("volume");
+        if (volume == null) {
+            throw CustomExceptions.VOLUME_MISSING;
+        }
+        if (volume < 0 || volume > 1) {
+            throw CustomExceptions.VOLUME_INVALID;
+        }
+        return volume;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/options/StartWatchingOptions.java

@@ -0,0 +1,17 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.options;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.PluginCall;
+
+public class StartWatchingOptions {
+
+    private final boolean suppressVolumeChange;
+
+    public StartWatchingOptions(@NonNull PluginCall call) {
+        this.suppressVolumeChange = call.getBoolean("suppressVolumeChange", false);
+    }
+
+    public boolean isSuppressVolumeChange() {
+        return suppressVolumeChange;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/results/GetVolumeResult.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.Result;
+
+public class GetVolumeResult implements Result {
+
+    private final double volume;
+
+    public GetVolumeResult(double volume) {
+        this.volume = volume;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("volume", volume);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/classes/results/IsWatchingResult.java

@@ -0,0 +1,22 @@
+package io.capawesome.capacitorjs.plugins.volume.classes.results;
+
+import androidx.annotation.NonNull;
+import com.getcapacitor.JSObject;
+import io.capawesome.capacitorjs.plugins.volume.interfaces.Result;
+
+public class IsWatchingResult implements Result {
+
+    private final boolean watching;
+
+    public IsWatchingResult(boolean watching) {
+        this.watching = watching;
+    }
+
+    @Override
+    @NonNull
+    public JSObject toJSObject() {
+        JSObject result = new JSObject();
+        result.put("watching", watching);
+        return result;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/interfaces/Callback.java

@@ -0,0 +1,5 @@
+package io.capawesome.capacitorjs.plugins.volume.interfaces;
+
+public interface Callback {
+    void error(Exception exception);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/interfaces/EmptyCallback.java

@@ -0,0 +1,5 @@
+package io.capawesome.capacitorjs.plugins.volume.interfaces;
+
+public interface EmptyCallback extends Callback {
+    void success();
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/interfaces/NonEmptyResultCallback.java

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.volume.interfaces;
+
+import androidx.annotation.NonNull;
+
+public interface NonEmptyResultCallback<T extends Result> extends Callback {
+    void success(@NonNull T result);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/volume/interfaces/Result.java

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.volume.interfaces;
+
+import com.getcapacitor.JSObject;
+
+public interface Result {
+    JSObject toJSObject();
+}