@capawesome/capacitor-silent-mode 0.0.1

package/CapawesomeCapacitorSilentMode.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapawesomeCapacitorSilentMode'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Plugin/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robin Genz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapawesomeCapacitorSilentMode",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapawesomeCapacitorSilentMode",
+            targets: ["SilentModePlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0")
+    ],
+    targets: [
+        .target(
+            name: "SilentModePlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Plugin"),
+        .testTarget(
+            name: "SilentModePluginTests",
+            dependencies: ["SilentModePlugin"],
+            path: "ios/PluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,242 @@
+# @capawesome/capacitor-silent-mode
+
+Capacitor plugin to detect whether the device is in silent mode.
+
+<div class="capawesome-z29o10a">
+  <a href="https://cloud.capawesome.io/" target="_blank">
+    <img alt="Deliver Live Updates to your Capacitor app with Capawesome Cloud" src="https://cloud.capawesome.io/assets/banners/cloud-build-and-deploy-capacitor-apps.png?t=1" />
+  </a>
+</div>
+
+## Features
+
+- 🔇 **Silent detection**: Check whether the device is currently in silent mode.
+- 🔔 **Ringer mode**: Read the exact ringer mode (normal, vibrate or silent) on Android.
+- 👂 **Change events**: Listen for changes to the silent mode state.
+- 📦 **CocoaPods & SPM**: Supports CocoaPods and Swift Package Manager for iOS.
+- 🔁 **Up-to-date**: Always supports the latest Capacitor version.
+
+Missing a feature? Just [open an issue](https://github.com/capawesome-team/capacitor-plugins/issues) and we'll take a look!
+
+## Newsletter
+
+Stay up to date with the latest news and updates about the Capawesome, Capacitor, and Ionic ecosystem by subscribing to our [Capawesome Newsletter](https://cloud.capawesome.io/newsletter/).
+
+## Compatibility
+
+| Plugin Version | Capacitor Version | Status         |
+| -------------- | ----------------- | -------------- |
+| 0.x.x          | >=8.x.x           | Active support |
+
+## Installation
+
+You can use our **AI-Assisted Setup** to install the plugin.
+Add the [Capawesome Skills](https://github.com/capawesome-team/skills) to your AI tool using the following command:
+
+```bash
+npx skills add capawesome-team/skills --skill capacitor-plugins
+```
+
+Then use the following prompt:
+
+```
+ Use the `capacitor-plugins` skill from `capawesome-team/skills` to install the `@capawesome/capacitor-silent-mode` plugin in my project.
+```
+
+If you prefer **Manual Setup**, install the plugin by running the following commands and follow the platform-specific instructions below:
+
+```bash
+npm install @capawesome/capacitor-silent-mode
+npx cap sync
+```
+
+This plugin is only available on **Android** and **iOS**. On the Web, all methods reject as unimplemented.
+
+## Configuration
+
+No configuration required for this plugin.
+
+## Usage
+
+```typescript
+import { SilentMode } from '@capawesome/capacitor-silent-mode';
+
+const isSilent = async () => {
+  const { silent } = await SilentMode.isSilent();
+  return silent;
+};
+
+const getRingerMode = async () => {
+  const { mode } = await SilentMode.getRingerMode();
+  return mode;
+};
+
+const addSilentModeChangeListener = async () => {
+  await SilentMode.addListener('silentModeChange', event => {
+    console.log('Silent mode changed:', event.silent);
+  });
+};
+
+const removeAllListeners = async () => {
+  await SilentMode.removeAllListeners();
+};
+```
+
+## API
+
+<docgen-index>
+
+* [`getRingerMode()`](#getringermode)
+* [`isSilent()`](#issilent)
+* [`addListener('silentModeChange', ...)`](#addlistenersilentmodechange-)
+* [`removeAllListeners()`](#removealllisteners)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### getRingerMode()
+
+```typescript
+getRingerMode() => Promise<GetRingerModeResult>
+```
+
+Get the current ringer mode of the device.
+
+Only available on Android.
+
+**Returns:** <code>Promise&lt;<a href="#getringermoderesult">GetRingerModeResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### isSilent()
+
+```typescript
+isSilent() => Promise<IsSilentResult>
+```
+
+Get the current silent mode state of the device.
+
+On Android, the device is considered silent if the ringer mode is not set
+to normal (that is, either vibrate or silent).
+
+On iOS, there is no public API to read the ring/silent switch. The state is
+therefore determined using a heuristic that plays a short muted system sound
+and measures how long it takes to complete. The result may be inaccurate
+while other audio is playing.
+
+Only available on Android and iOS.
+
+**Returns:** <code>Promise&lt;<a href="#issilentresult">IsSilentResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### addListener('silentModeChange', ...)
+
+```typescript
+addListener(eventName: 'silentModeChange', listenerFunc: (event: SilentModeChangeEvent) => void) => Promise<PluginListenerHandle>
+```
+
+Listen for changes to the silent mode state of the device.
+
+The device is only observed while at least one listener is attached.
+
+On iOS, the state is polled on a timer while the app is in the foreground
+and the listener is not called while the app is in the background.
+
+Only available on Android and iOS.
+
+| Param              | Type                                                                                        |
+| ------------------ | ------------------------------------------------------------------------------------------- |
+| **`eventName`**    | <code>'silentModeChange'</code>                                                             |
+| **`listenerFunc`** | <code>(event: <a href="#silentmodechangeevent">SilentModeChangeEvent</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### removeAllListeners()
+
+```typescript
+removeAllListeners() => Promise<void>
+```
+
+Remove all listeners for this plugin.
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### GetRingerModeResult
+
+| Prop       | Type                                              | Description                            | Since |
+| ---------- | ------------------------------------------------- | -------------------------------------- | ----- |
+| **`mode`** | <code><a href="#ringermode">RingerMode</a></code> | The current ringer mode of the device. | 0.1.0 |
+
+
+#### IsSilentResult
+
+| Prop         | Type                 | Description                                     | Since |
+| ------------ | -------------------- | ----------------------------------------------- | ----- |
+| **`silent`** | <code>boolean</code> | Whether the device is currently in silent mode. | 0.1.0 |
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+
+#### SilentModeChangeEvent
+
+| Prop         | Type                 | Description                                     | Since |
+| ------------ | -------------------- | ----------------------------------------------- | ----- |
+| **`silent`** | <code>boolean</code> | Whether the device is currently in silent mode. | 0.1.0 |
+
+
+### Type Aliases
+
+
+#### RingerMode
+
+The ringer mode of the device.
+
+- `normal`: The device plays sounds and rings for incoming calls.
+- `silent`: The device is silent and does not vibrate.
+- `vibrate`: The device is silent but vibrates.
+
+<code>'normal' | 'silent' | 'vibrate'</code>
+
+</docgen-api>
+
+## Silent Mode Detection
+
+Keep the following platform differences in mind when detecting silent mode:
+
+- **Android**: The silent mode state is derived from the [ringer mode](https://developer.android.com/reference/android/media/AudioManager#getRingerMode()). A device is considered silent whenever the ringer mode is not `normal`, which means that the vibrate mode also counts as silent. Use `getRingerMode()` if you need to distinguish between the vibrate and silent modes.
+- **iOS**: There is no public API to read the state of the ring/silent switch. The plugin therefore relies on a heuristic that plays a short muted system sound and measures how long it takes to complete. As a result, the detection may be inaccurate while other audio is playing or when the audio session category overrides the switch. The `silentModeChange` listener polls this heuristic on a timer while the app is in the foreground and pauses while the app is in the background.
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/silent-mode/CHANGELOG.md).
+
+## License
+
+See [LICENSE](https://github.com/capawesome-team/capacitor-plugins/blob/main/packages/silent-mode/LICENSE).

package/android/build.gradle

@@ -0,0 +1,58 @@
+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'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.13.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace = "io.capawesome.capacitorjs.plugins.silentmode"
+    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.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+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"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/io/capawesome/capacitorjs/plugins/silentmode/SilentMode.java

@@ -0,0 +1,90 @@
+package io.capawesome.capacitorjs.plugins.silentmode;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.media.AudioManager;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import io.capawesome.capacitorjs.plugins.silentmode.classes.events.SilentModeChangeEvent;
+import io.capawesome.capacitorjs.plugins.silentmode.classes.results.GetRingerModeResult;
+import io.capawesome.capacitorjs.plugins.silentmode.classes.results.IsSilentResult;
+import io.capawesome.capacitorjs.plugins.silentmode.interfaces.NonEmptyResultCallback;
+
+public class SilentMode {
+
+    @NonNull
+    private final SilentModePlugin plugin;
+
+    @NonNull
+    private final AudioManager audioManager;
+
+    private boolean isObserving = false;
+
+    private boolean lastSilent = false;
+
+    private final BroadcastReceiver ringerModeReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            handleRingerModeChanged();
+        }
+    };
+
+    public SilentMode(@NonNull SilentModePlugin plugin) {
+        this.plugin = plugin;
+        this.audioManager = (AudioManager) plugin.getContext().getSystemService(Context.AUDIO_SERVICE);
+    }
+
+    public void getRingerMode(@NonNull NonEmptyResultCallback<GetRingerModeResult> callback) {
+        String mode = mapRingerMode(audioManager.getRingerMode());
+        callback.success(new GetRingerModeResult(mode));
+    }
+
+    public void isSilent(@NonNull NonEmptyResultCallback<IsSilentResult> callback) {
+        callback.success(new IsSilentResult(isSilent()));
+    }
+
+    public void startObserving() {
+        if (isObserving) {
+            return;
+        }
+        lastSilent = isSilent();
+        IntentFilter filter = new IntentFilter(AudioManager.RINGER_MODE_CHANGED_ACTION);
+        ContextCompat.registerReceiver(plugin.getContext(), ringerModeReceiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED);
+        isObserving = true;
+    }
+
+    public void stopObserving() {
+        if (!isObserving) {
+            return;
+        }
+        plugin.getContext().unregisterReceiver(ringerModeReceiver);
+        isObserving = false;
+    }
+
+    private void handleRingerModeChanged() {
+        boolean silent = isSilent();
+        if (silent == lastSilent) {
+            return;
+        }
+        lastSilent = silent;
+        plugin.notifySilentModeChangeListeners(new SilentModeChangeEvent(silent));
+    }
+
+    private boolean isSilent() {
+        return audioManager.getRingerMode() != AudioManager.RINGER_MODE_NORMAL;
+    }
+
+    @NonNull
+    private String mapRingerMode(int ringerMode) {
+        switch (ringerMode) {
+            case AudioManager.RINGER_MODE_SILENT:
+                return "silent";
+            case AudioManager.RINGER_MODE_VIBRATE:
+                return "vibrate";
+            default:
+                return "normal";
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/silentmode/SilentModePlugin.java

@@ -0,0 +1,112 @@
+package io.capawesome.capacitorjs.plugins.silentmode;
+
+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.silentmode.classes.events.SilentModeChangeEvent;
+import io.capawesome.capacitorjs.plugins.silentmode.classes.results.GetRingerModeResult;
+import io.capawesome.capacitorjs.plugins.silentmode.classes.results.IsSilentResult;
+import io.capawesome.capacitorjs.plugins.silentmode.interfaces.NonEmptyResultCallback;
+import io.capawesome.capacitorjs.plugins.silentmode.interfaces.Result;
+
+@CapacitorPlugin(name = "SilentMode")
+public class SilentModePlugin extends Plugin {
+
+    public static final String EVENT_SILENT_MODE_CHANGE = "silentModeChange";
+
+    public static final String TAG = "SilentModePlugin";
+
+    private static final String ERROR_UNKNOWN_ERROR = "An unknown error occurred.";
+
+    private SilentMode implementation;
+
+    @Override
+    public void load() {
+        implementation = new SilentMode(this);
+    }
+
+    @Override
+    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+    public void addListener(PluginCall call) {
+        super.addListener(call);
+        implementation.startObserving();
+    }
+
+    @PluginMethod
+    public void getRingerMode(PluginCall call) {
+        try {
+            NonEmptyResultCallback<GetRingerModeResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull GetRingerModeResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.getRingerMode(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void isSilent(PluginCall call) {
+        try {
+            NonEmptyResultCallback<IsSilentResult> callback = new NonEmptyResultCallback<>() {
+                @Override
+                public void success(@NonNull IsSilentResult result) {
+                    resolveCall(call, result);
+                }
+
+                @Override
+                public void error(@NonNull Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.isSilent(callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    public void notifySilentModeChangeListeners(@NonNull SilentModeChangeEvent event) {
+        notifyListeners(EVENT_SILENT_MODE_CHANGE, event.toJSObject());
+    }
+
+    @Override
+    @PluginMethod
+    public void removeAllListeners(PluginCall call) {
+        super.removeAllListeners(call);
+        implementation.stopObserving();
+    }
+
+    @Override
+    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+    public void removeListener(PluginCall call) {
+        super.removeListener(call);
+        if (!hasListeners(EVENT_SILENT_MODE_CHANGE)) {
+            implementation.stopObserving();
+        }
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        Logger.error(TAG, message, exception);
+        call.reject(message);
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @NonNull Result result) {
+        call.resolve(result.toJSObject());
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/silentmode/classes/events/SilentModeChangeEvent.java

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

package/android/src/main/java/io/capawesome/capacitorjs/plugins/silentmode/classes/results/GetRingerModeResult.java

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

package/android/src/main/java/io/capawesome/capacitorjs/plugins/silentmode/classes/results/IsSilentResult.java

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

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

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

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

@@ -0,0 +1,7 @@
+package io.capawesome.capacitorjs.plugins.silentmode.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/silentmode/interfaces/Result.java

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