@capawesome/capacitor-volume 0.0.1

package/ios/Plugin/Classes/Results/IsWatchingResult.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Capacitor
+
+@objc public class IsWatchingResult: NSObject, Result {
+    let watching: Bool
+
+    init(watching: Bool) {
+        self.watching = watching
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["watching"] = watching
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Enums/CustomError.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+enum CustomError: Error {
+    case volumeInvalid
+    case volumeMissing
+
+    var code: String? {
+        switch self {
+        case .volumeInvalid, .volumeMissing:
+            return nil
+        }
+    }
+}
+
+extension CustomError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .volumeInvalid:
+            return NSLocalizedString("volume must be between 0 and 1.", comment: "volumeInvalid")
+        case .volumeMissing:
+            return NSLocalizedString("volume must be provided.", comment: "volumeMissing")
+        }
+    }
+}

package/ios/Plugin/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,5 @@
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/ios/Plugin/Volume.swift

@@ -0,0 +1,192 @@
+import AVFoundation
+import Capacitor
+import Foundation
+import MediaPlayer
+import UIKit
+
+@objc public class Volume: NSObject {
+    private static let directionDown = "down"
+    private static let directionUp = "up"
+    private static let maximumSuppressedVolume: Float = 0.875
+    private static let minimumSuppressedVolume: Float = 0.125
+    private static let minimumVolumeDelta: Float = 0.001
+    private static let programmaticChangeTolerance: Float = 0.05
+    private static let sliderSetDelay: TimeInterval = 0.1
+    private static let volumeViewRemovalDelay: TimeInterval = 0.5
+
+    private let audioSession = AVAudioSession.sharedInstance()
+    private let plugin: VolumePlugin
+
+    private var initialVolume: Float = 0
+    private var lastVolume: Float = 0
+    private var pendingSetVolume: Float?
+    private var suppressVolumeChange = false
+    private var volumeObservation: NSKeyValueObservation?
+    private var volumeView: MPVolumeView?
+    private var watching = false
+
+    init(plugin: VolumePlugin) {
+        self.plugin = plugin
+    }
+
+    deinit {
+        volumeObservation?.invalidate()
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc public func getVolume(completion: @escaping (_ result: GetVolumeResult?, _ error: Error?) -> Void) {
+        try? activateAudioSession()
+        completion(GetVolumeResult(volume: audioSession.outputVolume), nil)
+    }
+
+    @objc public func isWatching(completion: @escaping (_ result: IsWatchingResult?, _ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            completion(IsWatchingResult(watching: self.watching), nil)
+        }
+    }
+
+    @objc public func setVolume(_ options: SetVolumeOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            self.setSystemVolume(options.volume)
+            completion(nil)
+        }
+    }
+
+    @objc public func startWatching(_ options: StartWatchingOptions, completion: @escaping (_ error: Error?) -> Void) {
+        DispatchQueue.main.async {
+            if self.watching {
+                completion(nil)
+                return
+            }
+            do {
+                try self.activateAudioSession()
+            } catch {
+                completion(error)
+                return
+            }
+            self.suppressVolumeChange = options.suppressVolumeChange
+            self.initialVolume = self.audioSession.outputVolume
+            self.lastVolume = self.initialVolume
+            self.watching = true
+            if self.suppressVolumeChange {
+                self.addVolumeView()
+                self.applySuppressedVolume(self.initialVolume)
+            }
+            self.volumeObservation = self.audioSession.observe(\.outputVolume, options: [.new]) { [weak self] _, change in
+                guard let newVolume = change.newValue else {
+                    return
+                }
+                DispatchQueue.main.async {
+                    self?.handleVolumeChanged(newVolume)
+                }
+            }
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(self.handleDidBecomeActive),
+                name: UIApplication.didBecomeActiveNotification,
+                object: nil
+            )
+            completion(nil)
+        }
+    }
+
+    @objc public func stopWatching(completion: ((_ error: Error?) -> Void)? = nil) {
+        DispatchQueue.main.async {
+            if !self.watching {
+                completion?(nil)
+                return
+            }
+            self.volumeObservation?.invalidate()
+            self.volumeObservation = nil
+            NotificationCenter.default.removeObserver(self, name: UIApplication.didBecomeActiveNotification, object: nil)
+            self.watching = false
+            if self.suppressVolumeChange {
+                self.suppressVolumeChange = false
+                self.setSystemVolume(self.initialVolume)
+            }
+            self.pendingSetVolume = nil
+            try? self.audioSession.setActive(false, options: .notifyOthersOnDeactivation)
+            completion?(nil)
+        }
+    }
+
+    private func activateAudioSession() throws {
+        try audioSession.setCategory(.ambient, options: .mixWithOthers)
+        try audioSession.setActive(true)
+    }
+
+    private func addVolumeView() {
+        guard volumeView == nil else {
+            return
+        }
+        let volumeView = MPVolumeView(frame: CGRect(x: -3000, y: -3000, width: 100, height: 100))
+        plugin.bridge?.viewController?.view.addSubview(volumeView)
+        self.volumeView = volumeView
+    }
+
+    private func applySuppressedVolume(_ volume: Float) {
+        let suppressedVolume = min(max(volume, Self.minimumSuppressedVolume), Self.maximumSuppressedVolume)
+        if suppressedVolume != volume {
+            setSystemVolume(suppressedVolume)
+        }
+    }
+
+    @objc private func handleDidBecomeActive() {
+        try? activateAudioSession()
+        lastVolume = audioSession.outputVolume
+        if suppressVolumeChange {
+            applySuppressedVolume(lastVolume)
+        }
+    }
+
+    private func handleVolumeChanged(_ newVolume: Float) {
+        if let pendingSetVolume = pendingSetVolume, abs(newVolume - pendingSetVolume) < Self.programmaticChangeTolerance {
+            self.pendingSetVolume = nil
+            let changed = abs(newVolume - lastVolume) >= Self.minimumVolumeDelta
+            lastVolume = newVolume
+            if changed && !suppressVolumeChange {
+                plugin.notifyVolumeChangeListeners(VolumeChangeEvent(volume: newVolume))
+            }
+            return
+        }
+        let delta = newVolume - lastVolume
+        if abs(delta) < Self.minimumVolumeDelta {
+            return
+        }
+        let direction = delta > 0 ? Self.directionUp : Self.directionDown
+        plugin.notifyVolumeButtonPressedListeners(VolumeButtonPressedEvent(direction: direction))
+        if suppressVolumeChange {
+            setSystemVolume(lastVolume)
+        } else {
+            lastVolume = newVolume
+            plugin.notifyVolumeChangeListeners(VolumeChangeEvent(volume: newVolume))
+        }
+    }
+
+    private func removeVolumeView() {
+        volumeView?.removeFromSuperview()
+        volumeView = nil
+    }
+
+    private func setSystemVolume(_ volume: Float) {
+        addVolumeView()
+        if watching {
+            pendingSetVolume = volume
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.sliderSetDelay) { [weak self] in
+            guard let self = self else {
+                return
+            }
+            let slider = self.volumeView?.subviews.compactMap { $0 as? UISlider }.first
+            slider?.value = volume
+            if !(self.watching && self.suppressVolumeChange) {
+                DispatchQueue.main.asyncAfter(deadline: .now() + Self.volumeViewRemovalDelay) { [weak self] in
+                    guard let self = self, !(self.watching && self.suppressVolumeChange) else {
+                        return
+                    }
+                    self.removeVolumeView()
+                }
+            }
+        }
+    }
+}

package/ios/Plugin/VolumePlugin.swift

@@ -0,0 +1,109 @@
+import Foundation
+import Capacitor
+
+@objc(VolumePlugin)
+public class VolumePlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "VolumePlugin"
+    public let jsName = "Volume"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getVolume", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isWatching", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setVolume", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startWatching", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopWatching", returnType: CAPPluginReturnPromise)
+    ]
+
+    public static let eventVolumeButtonPressed = "volumeButtonPressed"
+    public static let eventVolumeChange = "volumeChange"
+    public static let tag = "VolumePlugin"
+
+    private var implementation: Volume?
+
+    @objc func getVolume(_ call: CAPPluginCall) {
+        implementation?.getVolume(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call, result)
+        })
+    }
+
+    @objc func isWatching(_ call: CAPPluginCall) {
+        implementation?.isWatching(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call, result)
+        })
+    }
+
+    override public func load() {
+        self.implementation = Volume(plugin: self)
+    }
+
+    @objc public func notifyVolumeButtonPressedListeners(_ event: VolumeButtonPressedEvent) {
+        self.notifyListeners(Self.eventVolumeButtonPressed, data: event.toJSObject() as? [String: Any])
+    }
+
+    @objc public func notifyVolumeChangeListeners(_ event: VolumeChangeEvent) {
+        self.notifyListeners(Self.eventVolumeChange, data: event.toJSObject() as? [String: Any])
+    }
+
+    @objc func setVolume(_ call: CAPPluginCall) {
+        do {
+            let options = try SetVolumeOptions(call)
+
+            implementation?.setVolume(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func startWatching(_ call: CAPPluginCall) {
+        let options = StartWatchingOptions(call)
+
+        implementation?.startWatching(options, completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call)
+        })
+    }
+
+    @objc func stopWatching(_ call: CAPPluginCall) {
+        implementation?.stopWatching { error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call)
+        }
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", VolumePlugin.tag, "] ", error)
+        let code = (error as? CustomError)?.code
+        call.reject(error.localizedDescription, code)
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@capawesome/capacitor-volume",
+  "version": "0.0.1",
+  "description": "Capacitor plugin to control the volume and observe hardware volume button presses.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "CapawesomeCapacitorVolume.podspec",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "homepage": "https://capawesome.io/docs/plugins/volume/",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api VolumePlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:pod:install": "cd ios && pod install --repo-update && cd ..",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "eslint": "8.57.0",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}