@independo/capacitor-voice-recorder 8.1.0-dev.1 → 8.1.0-dev.3

package/ios/Sources/VoiceRecorder/Bridge/VoiceRecorder.swift

@@ -0,0 +1,172 @@
+import Foundation
+import AVFoundation
+import Capacitor
+
+/// Capacitor bridge for the VoiceRecorder plugin.
+@objc(VoiceRecorder)
+public class VoiceRecorder: CAPPlugin, CAPBridgedPlugin {
+    /// Plugin identifier used by Capacitor.
+    public let identifier = "VoiceRecorder"
+    /// JavaScript name used for the plugin proxy.
+    public let jsName = "VoiceRecorder"
+    /// Supported plugin methods exposed to the JS layer.
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "canDeviceVoiceRecord", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestAudioRecordingPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "hasAudioRecordingPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startRecording", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopRecording", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "pauseRecording", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "resumeRecording", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getCurrentStatus", returnType: CAPPluginReturnPromise),
+    ]
+
+    /// Service layer that performs recording operations.
+    private var service: VoiceRecorderService?
+    /// Response format derived from plugin configuration.
+    private var responseFormat: ResponseFormat = .legacy
+
+    /// Initializes dependencies after the plugin loads.
+    public override func load() {
+        super.load()
+        responseFormat = ResponseFormat(config: getConfig())
+        service = VoiceRecorderService(
+            platform: DefaultRecorderPlatform(),
+            permissionChecker: { [weak self] in
+                self?.doesUserGaveAudioRecordingPermission() ?? false
+            }
+        )
+    }
+
+    /// Returns whether the device can record audio.
+    @objc func canDeviceVoiceRecord(_ call: CAPPluginCall) {
+        let canRecord = service?.canDeviceVoiceRecord() ?? false
+        call.resolve(ResponseGenerator.fromBoolean(canRecord))
+    }
+
+    /// Requests microphone permission from the user.
+    @objc func requestAudioRecordingPermission(_ call: CAPPluginCall) {
+        AVAudioSession.sharedInstance().requestRecordPermission { granted in
+            if granted {
+                call.resolve(ResponseGenerator.successResponse())
+            } else {
+                call.resolve(ResponseGenerator.failResponse())
+            }
+        }
+    }
+
+    /// Returns whether the app has microphone permission.
+    @objc func hasAudioRecordingPermission(_ call: CAPPluginCall) {
+        let hasPermission = service?.hasAudioRecordingPermission() ?? false
+        call.resolve(ResponseGenerator.fromBoolean(hasPermission))
+    }
+
+    /// Starts a recording session with optional file output.
+    @objc func startRecording(_ call: CAPPluginCall) {
+        guard let service = service else {
+            call.reject(Messages.FAILED_TO_RECORD, ErrorCodes.failedToRecord)
+            return
+        }
+
+        let directory: String? = call.getString("directory")
+        let subDirectory: String? = call.getString("subDirectory")
+        let recordOptions = RecordOptions(directory: directory, subDirectory: subDirectory)
+        do {
+            try service.startRecording(
+                options: recordOptions,
+                onInterruptionBegan: { [weak self] in
+                    self?.notifyListeners("voiceRecordingInterrupted", data: [:])
+                },
+                onInterruptionEnded: { [weak self] in
+                    self?.notifyListeners("voiceRecordingInterruptionEnded", data: [:])
+                }
+            )
+            call.resolve(ResponseGenerator.successResponse())
+        } catch let error as VoiceRecorderServiceError {
+            call.reject(toLegacyMessage(error.code), error.code, error.underlyingError ?? error)
+        } catch {
+            call.reject(Messages.FAILED_TO_RECORD, ErrorCodes.failedToRecord, error)
+        }
+    }
+
+    /// Stops recording and returns the audio payload.
+    @objc func stopRecording(_ call: CAPPluginCall) {
+        guard let service = service else {
+            call.reject(Messages.FAILED_TO_FETCH_RECORDING, ErrorCodes.failedToFetchRecording)
+            return
+        }
+
+        service.stopRecording { [weak self] result in
+            DispatchQueue.main.async {
+                guard let self = self else {
+                    call.reject(Messages.FAILED_TO_FETCH_RECORDING, ErrorCodes.failedToFetchRecording)
+                    return
+                }
+
+                switch result {
+                case .success(let recordData):
+                    let payload: Dictionary<String, Any>
+                    if self.responseFormat == .normalized {
+                        payload = RecordDataMapper.toNormalizedDictionary(recordData)
+                    } else {
+                        payload = RecordDataMapper.toLegacyDictionary(recordData)
+                    }
+                    call.resolve(ResponseGenerator.dataResponse(payload))
+                case .failure(let error):
+                    call.reject(self.toLegacyMessage(error.code), error.code, error.underlyingError ?? error)
+                }
+            }
+        }
+    }
+
+    /// Pauses a recording session if supported.
+    @objc func pauseRecording(_ call: CAPPluginCall) {
+        guard let service = service else {
+            call.reject(Messages.RECORDING_HAS_NOT_STARTED, ErrorCodes.recordingHasNotStarted)
+            return
+        }
+
+        do {
+            call.resolve(ResponseGenerator.fromBoolean(try service.pauseRecording()))
+        } catch let error as VoiceRecorderServiceError {
+            call.reject(toLegacyMessage(error.code), error.code, error.underlyingError ?? error)
+        } catch {
+            call.reject(Messages.FAILED_TO_RECORD, ErrorCodes.failedToRecord, error)
+        }
+    }
+
+    /// Resumes a paused recording session if supported.
+    @objc func resumeRecording(_ call: CAPPluginCall) {
+        guard let service = service else {
+            call.reject(Messages.RECORDING_HAS_NOT_STARTED, ErrorCodes.recordingHasNotStarted)
+            return
+        }
+
+        do {
+            call.resolve(ResponseGenerator.fromBoolean(try service.resumeRecording()))
+        } catch let error as VoiceRecorderServiceError {
+            call.reject(toLegacyMessage(error.code), error.code, error.underlyingError ?? error)
+        } catch {
+            call.reject(Messages.FAILED_TO_RECORD, ErrorCodes.failedToRecord, error)
+        }
+    }
+
+    /// Returns the current recording status.
+    @objc func getCurrentStatus(_ call: CAPPluginCall) {
+        let status = service?.getCurrentStatus() ?? .NONE
+        call.resolve(ResponseGenerator.statusResponse(status))
+    }
+
+    /// Returns whether AVAudioSession reports granted permission.
+    func doesUserGaveAudioRecordingPermission() -> Bool {
+        return AVAudioSession.sharedInstance().recordPermission == AVAudioSession.RecordPermission.granted
+    }
+
+    /// Maps canonical error codes back to legacy messages.
+    private func toLegacyMessage(_ canonicalCode: String) -> String {
+        if canonicalCode == ErrorCodes.deviceCannotVoiceRecord {
+            return Messages.CANNOT_RECORD_ON_THIS_PHONE
+        }
+        return canonicalCode
+    }
+}

package/ios/Sources/VoiceRecorder/{CurrentRecordingStatus.swift → Core/CurrentRecordingStatus.swift}

@@ -1,5 +1,6 @@
 import Foundation
 
+/// Represents the current recording state.
 enum CurrentRecordingStatus: String {
 
     case RECORDING

package/ios/Sources/VoiceRecorder/Core/ErrorCodes.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+/// Canonical error codes returned by the plugin.
+struct ErrorCodes {
+    static let missingPermission = "MISSING_PERMISSION"
+    static let alreadyRecording = "ALREADY_RECORDING"
+    static let microphoneBeingUsed = "MICROPHONE_BEING_USED"
+    static let deviceCannotVoiceRecord = "DEVICE_CANNOT_VOICE_RECORD"
+    static let failedToRecord = "FAILED_TO_RECORD"
+    static let emptyRecording = "EMPTY_RECORDING"
+    static let recordingHasNotStarted = "RECORDING_HAS_NOT_STARTED"
+    static let failedToFetchRecording = "FAILED_TO_FETCH_RECORDING"
+    static let failedToMergeRecording = "FAILED_TO_MERGE_RECORDING"
+    static let notSupportedOsVersion = "NOT_SUPPORTED_OS_VERSION"
+    static let couldNotQueryPermissionStatus = "COULD_NOT_QUERY_PERMISSION_STATUS"
+}

package/ios/Sources/VoiceRecorder/{Messages.swift → Core/Messages.swift}

@@ -1,5 +1,6 @@
 import Foundation
 
+/// Legacy error messages preserved for backward compatibility.
 struct Messages {
 
     static let MISSING_PERMISSION = "MISSING_PERMISSION"

package/ios/Sources/VoiceRecorder/{RecordData.swift → Core/RecordData.swift}

@@ -1,12 +1,18 @@
 import Foundation
 
+/// Recording payload returned to the bridge layer.
 struct RecordData {
 
+    /// Base64-encoded recording data (legacy payloads).
     public let recordDataBase64: String?
+    /// MIME type of the recorded audio.
     public let mimeType: String
+    /// Recording duration in milliseconds.
     public let msDuration: Int
+    /// File path or URI to the recorded audio.
     public let uri: String?
 
+    /// Serializes record data into the legacy payload shape.
     public func toDictionary() -> Dictionary<String, Any> {
         return [
             "recordDataBase64": recordDataBase64 ?? "",

package/ios/Sources/VoiceRecorder/Core/RecordOptions.swift

@@ -0,0 +1,11 @@
+import Foundation
+
+/// Optional output configuration for recordings.
+struct RecordOptions {
+
+    /// Directory name provided by the caller.
+    public let directory: String?
+    /// Subdirectory name provided by the caller.
+    public let subDirectory: String?
+
+}

package/ios/Sources/VoiceRecorder/Core/ResponseFormat.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Capacitor
+
+/// Supported response payload shapes.
+enum ResponseFormat: String {
+    case legacy
+    case normalized
+
+    /// Converts a raw config value into a response format.
+    static func from(value: String?) -> ResponseFormat {
+        guard let value = value?.lowercased(), value == "normalized" else {
+            return .legacy
+        }
+        return .normalized
+    }
+
+    /// Reads the response format from plugin configuration.
+    init(config: PluginConfig) {
+        let value = config.getString("responseFormat", "legacy") ?? "legacy"
+        self = ResponseFormat.from(value: value)
+    }
+}

package/ios/Sources/VoiceRecorder/{ResponseGenerator.swift → Core/ResponseGenerator.swift}

@@ -1,26 +1,32 @@
 import Foundation
 
+/// Helper for building JS payloads in the legacy response shape.
 struct ResponseGenerator {
 
     private static let VALUE_RESPONSE_KEY = "value"
     private static let STATUS_RESPONSE_KEY = "status"
 
+    /// Wraps a boolean value into the response shape.
     public static func fromBoolean(_ value: Bool) -> Dictionary<String, Bool> {
         return value ? successResponse() : failResponse()
     }
 
+    /// Returns a success response with value=true.
     public static func successResponse() -> Dictionary<String, Bool> {
         return [VALUE_RESPONSE_KEY: true]
     }
 
+    /// Returns a failure response with value=false.
     public static func failResponse() -> Dictionary<String, Bool> {
         return [VALUE_RESPONSE_KEY: false]
     }
 
+    /// Wraps arbitrary data into the response shape.
     public static func dataResponse(_ data: Any) -> Dictionary<String, Any> {
         return [VALUE_RESPONSE_KEY: data]
     }
 
+    /// Wraps the recording status into the response shape.
     public static func statusResponse(_ data: CurrentRecordingStatus) -> Dictionary<String, String> {
         return [STATUS_RESPONSE_KEY: data.rawValue]
     }

package/ios/Sources/VoiceRecorder/{CustomMediaRecorder.swift → Platform/CustomMediaRecorder.swift}

@@ -1,26 +1,70 @@
 import Foundation
 import AVFoundation
 
-class CustomMediaRecorder {
+protocol AudioSessionProtocol: AnyObject {
+    var category: AVAudioSession.Category { get }
+    func setCategory(_ category: AVAudioSession.Category) throws
+    func setActive(_ active: Bool, options: AVAudioSession.SetActiveOptions) throws
+}
+
+protocol AudioRecorderProtocol: AnyObject {
+    @discardableResult
+    func record() -> Bool
+    func stop()
+    func pause()
+}
+
+typealias AudioRecorderFactory = (_ url: URL, _ settings: [String: Any]) throws -> AudioRecorderProtocol
+
+extension AVAudioSession: AudioSessionProtocol {}
+extension AVAudioRecorder: AudioRecorderProtocol {}
 
+/// AVAudioRecorder wrapper that supports interruptions and segment merging.
+class CustomMediaRecorder: RecorderAdapter {
+
+    private let audioSessionProvider: () -> AudioSessionProtocol
+    private let audioRecorderFactory: AudioRecorderFactory
+
+    /// Options provided by the service layer.
     public var options: RecordOptions?
-    private var recordingSession: AVAudioSession!
-    private var audioRecorder: AVAudioRecorder!
+    /// Active audio session for recording.
+    private var recordingSession: AudioSessionProtocol!
+    /// Active recorder instance for the current segment.
+    private var audioRecorder: AudioRecorderProtocol!
+    /// Base file path for the merged recording.
     private var baseAudioFilePath: URL!
+    /// List of segment files created during interruptions.
     private var audioFileSegments: [URL] = []
+    /// Audio session category before recording starts.
     private var originalRecordingSessionCategory: AVAudioSession.Category!
+    /// Current recording status.
     private var status = CurrentRecordingStatus.NONE
+    /// Notification observer for audio interruptions.
     private var interruptionObserver: NSObjectProtocol?
+    /// Callback invoked when interruptions begin.
     var onInterruptionBegan: (() -> Void)?
+    /// Callback invoked when interruptions end.
     var onInterruptionEnded: (() -> Void)?
 
-    private let settings = [
+    /// Recorder settings used for all segments.
+    private let settings: [String: Any] = [
         AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
         AVSampleRateKey: 44100,
         AVNumberOfChannelsKey: 1,
         AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
     ]
 
+    init(
+        audioSessionProvider: @escaping () -> AudioSessionProtocol = { AVAudioSession.sharedInstance() },
+        audioRecorderFactory: @escaping AudioRecorderFactory = { url, settings in
+            return try AVAudioRecorder(url: url, settings: settings)
+        }
+    ) {
+        self.audioSessionProvider = audioSessionProvider
+        self.audioRecorderFactory = audioRecorderFactory
+    }
+
+    /// Resolves the directory where audio files should be saved.
     private func getDirectoryToSaveAudioFile() -> URL {
 	if options?.directory != nil,
 	   let directory = getDirectory(directory: options?.directory),
@@ -43,16 +87,17 @@ class CustomMediaRecorder {
         return URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
     }
 
+    /// Starts recording audio and prepares the session.
     public func startRecording(recordOptions: RecordOptions?) -> Bool {
         do {
             options = recordOptions
-            recordingSession = AVAudioSession.sharedInstance()
+            recordingSession = audioSessionProvider()
             originalRecordingSessionCategory = recordingSession.category
             try recordingSession.setCategory(AVAudioSession.Category.playAndRecord)
-            try recordingSession.setActive(true)
+            try recordingSession.setActive(true, options: [])
             baseAudioFilePath = getDirectoryToSaveAudioFile().appendingPathComponent("recording-\(Int(Date().timeIntervalSince1970 * 1000)).aac")
             audioFileSegments = [baseAudioFilePath]
-            audioRecorder = try AVAudioRecorder(url: baseAudioFilePath, settings: settings)
+            audioRecorder = try audioRecorderFactory(baseAudioFilePath, settings)
             setupInterruptionHandling()
             audioRecorder.record()
             status = CurrentRecordingStatus.RECORDING
@@ -62,6 +107,7 @@ class CustomMediaRecorder {
         }
     }
 
+    /// Stops recording and merges segments if needed.
     public func stopRecording(completion: @escaping (Bool) -> Void) {
         removeInterruptionHandling()
         audioRecorder.stop()
@@ -73,7 +119,7 @@ class CustomMediaRecorder {
             }
 
             do {
-                try self.recordingSession.setActive(false)
+                try self.recordingSession.setActive(false, options: [])
                 try self.recordingSession.setCategory(self.originalRecordingSessionCategory)
             } catch {
             }
@@ -100,10 +146,12 @@ class CustomMediaRecorder {
         }
     }
 
+    /// Returns the output file for the recording.
     public func getOutputFile() -> URL {
         return baseAudioFilePath
     }
 
+    /// Maps directory strings to FileManager search paths.
     public func getDirectory(directory: String?) -> FileManager.SearchPathDirectory? {
         if let directory = directory {
             switch directory {
@@ -118,6 +166,7 @@ class CustomMediaRecorder {
         return nil
     }
 
+    /// Pauses recording when currently active.
     public func pauseRecording() -> Bool {
         if(status == CurrentRecordingStatus.RECORDING) {
             audioRecorder.pause()
@@ -128,17 +177,18 @@ class CustomMediaRecorder {
         }
     }
 
+    /// Resumes recording after pause or interruption.
     public func resumeRecording() -> Bool {
         if(status == CurrentRecordingStatus.PAUSED || status == CurrentRecordingStatus.INTERRUPTED) {
             let wasInterrupted = status == CurrentRecordingStatus.INTERRUPTED
             do {
-                try recordingSession.setActive(true)
+                try recordingSession.setActive(true, options: [])
                 if status == CurrentRecordingStatus.INTERRUPTED {
                     let directory = getDirectoryToSaveAudioFile()
                     let timestamp = Int(Date().timeIntervalSince1970 * 1000)
                     let segmentNumber = audioFileSegments.count
                     let segmentPath = directory.appendingPathComponent("recording-\(timestamp)-segment-\(segmentNumber).aac")
-                    audioRecorder = try AVAudioRecorder(url: segmentPath, settings: settings)
+                    audioRecorder = try audioRecorderFactory(segmentPath, settings)
                     audioFileSegments.append(segmentPath)
                 }
                 audioRecorder.record()
@@ -146,7 +196,7 @@ class CustomMediaRecorder {
                 return true
             } catch {
                 if wasInterrupted {
-                    try? recordingSession.setActive(false)
+                    try? recordingSession.setActive(false, options: [])
                 }
                 return false
             }
@@ -155,20 +205,23 @@ class CustomMediaRecorder {
         return false
     }
 
+    /// Returns the current recording status.
     public func getCurrentStatus() -> CurrentRecordingStatus {
         return status
     }
 
+    /// Registers for interruption notifications.
     private func setupInterruptionHandling() {
         interruptionObserver = NotificationCenter.default.addObserver(
             forName: AVAudioSession.interruptionNotification,
-            object: AVAudioSession.sharedInstance(),
+            object: recordingSession,
             queue: .main
         ) { [weak self] notification in
             self?.handleInterruption(notification: notification)
         }
     }
 
+    /// Removes interruption observers.
     private func removeInterruptionHandling() {
         if let observer = interruptionObserver {
             NotificationCenter.default.removeObserver(observer)
@@ -176,6 +229,7 @@ class CustomMediaRecorder {
         }
     }
 
+    /// Handles audio session interruptions.
     private func handleInterruption(notification: Notification) {
         guard let userInfo = notification.userInfo,
               let interruptionTypeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
@@ -201,6 +255,7 @@ class CustomMediaRecorder {
         }
     }
 
+    /// Merges recorded segments into a single file when interruptions occur.
     private func mergeAudioSegments(completion: @escaping (Bool) -> Void) {
         if audioFileSegments.count <= 1 {
             completion(true)

package/ios/Sources/VoiceRecorder/Service/VoiceRecorderService.swift

@@ -0,0 +1,128 @@
+import Foundation
+
+/// Service layer that orchestrates recording operations.
+final class VoiceRecorderService {
+    /// Platform adapter for device and file operations.
+    private let platform: RecorderPlatform
+    /// Closure used to check microphone permission.
+    private let permissionChecker: () -> Bool
+    /// Factory for creating recorder adapters.
+    private let recorderFactory: () -> RecorderAdapter
+    /// Active recorder instance for the current session.
+    private var recorder: RecorderAdapter?
+
+    init(
+        platform: RecorderPlatform,
+        permissionChecker: @escaping () -> Bool,
+        recorderFactory: @escaping () -> RecorderAdapter = { CustomMediaRecorder() }
+    ) {
+        self.platform = platform
+        self.permissionChecker = permissionChecker
+        self.recorderFactory = recorderFactory
+    }
+
+    /// Returns whether the device can record audio.
+    func canDeviceVoiceRecord() -> Bool {
+        return platform.canDeviceVoiceRecord()
+    }
+
+    /// Returns whether the app has microphone permission.
+    func hasAudioRecordingPermission() -> Bool {
+        return permissionChecker()
+    }
+
+    /// Starts a recording session or throws a service error.
+    func startRecording(
+        options: RecordOptions?,
+        onInterruptionBegan: @escaping () -> Void,
+        onInterruptionEnded: @escaping () -> Void
+    ) throws {
+        if !platform.canDeviceVoiceRecord() {
+            throw VoiceRecorderServiceError(code: ErrorCodes.deviceCannotVoiceRecord)
+        }
+
+        if !permissionChecker() {
+            throw VoiceRecorderServiceError(code: ErrorCodes.missingPermission)
+        }
+
+        if recorder != nil {
+            throw VoiceRecorderServiceError(code: ErrorCodes.alreadyRecording)
+        }
+
+        let nextRecorder = recorderFactory()
+        nextRecorder.onInterruptionBegan = onInterruptionBegan
+        nextRecorder.onInterruptionEnded = onInterruptionEnded
+        let started = nextRecorder.startRecording(recordOptions: options)
+        if !started {
+            recorder = nil
+            throw VoiceRecorderServiceError(code: ErrorCodes.deviceCannotVoiceRecord)
+        }
+
+        recorder = nextRecorder
+    }
+
+    /// Stops recording and returns the payload asynchronously.
+    func stopRecording(completion: @escaping (Result<RecordData, VoiceRecorderServiceError>) -> Void) {
+        guard let recorder = recorder else {
+            completion(.failure(VoiceRecorderServiceError(code: ErrorCodes.recordingHasNotStarted)))
+            return
+        }
+
+        recorder.stopRecording { [weak self] stopSuccess in
+            guard let self = self else {
+                completion(.failure(VoiceRecorderServiceError(code: ErrorCodes.failedToFetchRecording)))
+                return
+            }
+
+            if !stopSuccess {
+                self.recorder = nil
+                completion(.failure(VoiceRecorderServiceError(code: ErrorCodes.failedToMergeRecording)))
+                return
+            }
+
+            let audioFileUrl = recorder.getOutputFile()
+            let fileExtension = audioFileUrl.pathExtension.lowercased()
+            let mimeType = fileExtension == "m4a" ? "audio/mp4" : "audio/aac"
+            let sendDataAsBase64 = recorder.options?.directory == nil
+            let recordDataBase64 = sendDataAsBase64 ? self.platform.readFileAsBase64(audioFileUrl) : nil
+            let uri = sendDataAsBase64 ? nil : audioFileUrl.path
+            let recordData = RecordData(
+                recordDataBase64: recordDataBase64,
+                mimeType: mimeType,
+                msDuration: self.platform.getDurationMs(audioFileUrl),
+                uri: uri
+            )
+
+            self.recorder = nil
+            if (sendDataAsBase64 && recordData.recordDataBase64 == nil) || recordData.msDuration < 0 {
+                completion(.failure(VoiceRecorderServiceError(code: ErrorCodes.emptyRecording)))
+            } else {
+                completion(.success(recordData))
+            }
+        }
+    }
+
+    /// Pauses the active recording session.
+    func pauseRecording() throws -> Bool {
+        guard let recorder = recorder else {
+            throw VoiceRecorderServiceError(code: ErrorCodes.recordingHasNotStarted)
+        }
+        return recorder.pauseRecording()
+    }
+
+    /// Resumes a paused recording session.
+    func resumeRecording() throws -> Bool {
+        guard let recorder = recorder else {
+            throw VoiceRecorderServiceError(code: ErrorCodes.recordingHasNotStarted)
+        }
+        return recorder.resumeRecording()
+    }
+
+    /// Returns the current recording status.
+    func getCurrentStatus() -> CurrentRecordingStatus {
+        guard let recorder = recorder else {
+            return .NONE
+        }
+        return recorder.getCurrentStatus()
+    }
+}

package/ios/Sources/VoiceRecorder/Service/VoiceRecorderServiceError.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+/// Error wrapper that carries a canonical error code.
+struct VoiceRecorderServiceError: Error {
+    /// Canonical error code for bridge mapping.
+    let code: String
+    /// Underlying error, when available.
+    let underlyingError: Error?
+
+    init(code: String, underlyingError: Error? = nil) {
+        self.code = code
+        self.underlyingError = underlyingError
+    }
+}

package/package.json

@@ -13,7 +13,7 @@
     "url": "https://github.com/independo-gmbh/capacitor-voice-recorder.git"
   },
   "description": "Capacitor plugin for voice recording",
-  "version": "8.1.0-dev.1",
+  "version": "8.1.0-dev.3",
   "devDependencies": {
     "@capacitor/android": "^8.0.0",
     "conventional-changelog-conventionalcommits": "^9.1.0",
@@ -60,12 +60,18 @@
     "prepublishOnly": "npm run build",
     "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
     "verify:android": "node scripts/verify-android.js",
+    "verify:ios": "xcodebuild -scheme IndependoCapacitorVoiceRecorder -destination generic/platform=iOS",
+    "verify:web": "npm run build",
     "watch": "tsc --watch",
-    "test": "jest",
+    "test": "npm run test:web && npm run test:android && npm run test:ios",
+    "test:web": "jest",
+    "test:web:coverage": "jest --coverage --coverageReporters=lcov --coverageReporters=text-summary",
+    "test:android": "node scripts/verify-android.js testDebugUnitTest",
+    "test:android:coverage": "node scripts/verify-android.js testDebugUnitTest jacocoTestReport",
+    "test:ios": "node scripts/test-ios.js",
+    "test:ios:coverage": "node scripts/test-ios.js --coverage --result-bundle-path coverage/ios.xcresult && node scripts/xccov-to-cobertura.js --xcresult coverage/ios.xcresult --output coverage/ios-cobertura.xml",
     "eslint": "eslint . --ext ts",
-    "verify:ios": "xcodebuild -scheme IndependoCapacitorVoiceRecorder -destination generic/platform=iOS",
     "clean": "rm -rf dist",
-    "verify:web": "npm run build",
     "swiftlint": "node-swiftlint",
     "docgen": "docgen --api VoiceRecorderPlugin --output-readme README.md --output-json dist/docs.json",
     "fmt": "npm run eslint -- --fix"