@scr2em/capacitor-plugin-recorder 0.0.1

package/ios/Sources/RecorderPlayerPlugin/RecorderPlayer.swift

@@ -0,0 +1,318 @@
+import Foundation
+import AVFoundation
+
+public enum RecordingStatus: String {
+    case recording = "recording"
+    case paused = "paused"
+    case stopped = "stopped"
+}
+
+public enum PlaybackStatus: String {
+    case playing = "playing"
+    case paused = "paused"
+    case stopped = "stopped"
+    case ended = "ended"
+}
+
+public protocol RecorderPlayerDelegate: AnyObject {
+    func onRecordingStatusChange(status: RecordingStatus, duration: Int)
+    func onPlaybackStatusChange(playerId: String, status: PlaybackStatus, currentPosition: Int, duration: Int)
+}
+
+// Internal class to hold player state
+private class PlayerState: NSObject, AVAudioPlayerDelegate {
+    let playerId: String
+    let audioPlayer: AVAudioPlayer
+    var status: PlaybackStatus = .stopped
+    var playbackTimer: Timer?
+    weak var delegate: RecorderPlayerDelegate?
+
+    init(playerId: String, audioPlayer: AVAudioPlayer) {
+        self.playerId = playerId
+        self.audioPlayer = audioPlayer
+        super.init()
+        self.audioPlayer.delegate = self
+    }
+
+    func startTimer() {
+        stopTimer()
+        playbackTimer = Timer.scheduledTimer(withTimeInterval: 0.25, repeats: true) { [weak self] _ in
+            self?.notifyStatusChange()
+        }
+    }
+
+    func stopTimer() {
+        playbackTimer?.invalidate()
+        playbackTimer = nil
+    }
+
+    func notifyStatusChange() {
+        let currentPosition = Int(audioPlayer.currentTime * 1000)
+        let duration = Int(audioPlayer.duration * 1000)
+        delegate?.onPlaybackStatusChange(playerId: playerId, status: status, currentPosition: currentPosition, duration: duration)
+    }
+
+    // AVAudioPlayerDelegate
+    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+        status = .ended
+        stopTimer()
+        notifyStatusChange()
+    }
+
+    func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error: Error?) {
+        status = .stopped
+        stopTimer()
+        notifyStatusChange()
+    }
+
+    deinit {
+        stopTimer()
+    }
+}
+
+@objc public class RecorderPlayer: NSObject {
+    private var audioRecorder: AVAudioRecorder?
+    private var recordingSession: AVAudioSession?
+
+    private var recordingStatus: RecordingStatus = .stopped
+
+    private var recordingStartTime: Date?
+    private var pausedDuration: TimeInterval = 0
+    private var currentRecordingPath: URL?
+
+    // Multiple players support
+    private var players: [String: PlayerState] = [:]
+    private var playerIdCounter: Int = 0
+
+    public weak var delegate: RecorderPlayerDelegate?
+
+    public override init() {
+        super.init()
+        setupAudioSession()
+    }
+
+    private func setupAudioSession() {
+        recordingSession = AVAudioSession.sharedInstance()
+        do {
+            try recordingSession?.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker, .allowBluetooth, .mixWithOthers])
+            try recordingSession?.setActive(true)
+        } catch {
+            print("Failed to setup audio session: \(error)")
+        }
+    }
+
+    private func generatePlayerId() -> String {
+        playerIdCounter += 1
+        return "player-\(playerIdCounter)-\(Int(Date().timeIntervalSince1970 * 1000))"
+    }
+
+    @objc public func startRecord(path: String?) throws {
+        guard recordingStatus == .stopped else {
+            throw NSError(domain: "RecorderPlayer", code: 1, userInfo: [NSLocalizedDescriptionKey: "Recording already in progress"])
+        }
+
+        // Use Application Support directory + bundle identifier (matches Capacitor's Directory.Data)
+        let appSupportDir = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        let dataDir = appSupportDir.appendingPathComponent(Bundle.main.bundleIdentifier ?? "")
+        // Create directory if it doesn't exist
+        try? FileManager.default.createDirectory(at: dataDir, withIntermediateDirectories: true)
+
+        let audioPath: URL
+        if let path = path {
+            // Use relative path within data directory
+            audioPath = dataDir.appendingPathComponent(path)
+            // Create parent directories if needed
+            let parentDir = audioPath.deletingLastPathComponent()
+            try? FileManager.default.createDirectory(at: parentDir, withIntermediateDirectories: true)
+        } else {
+            let audioFilename = "recording_\(Int(Date().timeIntervalSince1970)).m4a"
+            audioPath = dataDir.appendingPathComponent(audioFilename)
+        }
+
+        currentRecordingPath = audioPath
+
+        let settings: [String: Any] = [
+            AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
+            AVSampleRateKey: 44100,
+            AVNumberOfChannelsKey: 1,
+            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+        ]
+
+        do {
+            audioRecorder = try AVAudioRecorder(url: audioPath, settings: settings)
+            audioRecorder?.record()
+            recordingStartTime = Date()
+            pausedDuration = 0
+            recordingStatus = .recording
+            notifyRecordingStatusChange()
+        } catch {
+            throw NSError(domain: "RecorderPlayer", code: 2, userInfo: [NSLocalizedDescriptionKey: "Failed to start recording: \(error.localizedDescription)"])
+        }
+    }
+
+    @objc public func stopRecord() throws -> (path: String, duration: Int) {
+        guard let recorder = audioRecorder, recordingStatus != .stopped else {
+            throw NSError(domain: "RecorderPlayer", code: 3, userInfo: [NSLocalizedDescriptionKey: "No recording in progress"])
+        }
+
+        let duration = Int(recorder.currentTime * 1000)
+        recorder.stop()
+
+        let path = currentRecordingPath?.path ?? ""
+
+        audioRecorder = nil
+        recordingStatus = .stopped
+        notifyRecordingStatusChange()
+
+        return (path, duration)
+    }
+
+    @objc public func pauseRecord() throws {
+        guard let recorder = audioRecorder, recordingStatus == .recording else {
+            throw NSError(domain: "RecorderPlayer", code: 4, userInfo: [NSLocalizedDescriptionKey: "No active recording to pause"])
+        }
+
+        recorder.pause()
+        pausedDuration = recorder.currentTime
+        recordingStatus = .paused
+        notifyRecordingStatusChange()
+    }
+
+    @objc public func resumeRecord() throws {
+        guard let recorder = audioRecorder, recordingStatus == .paused else {
+            throw NSError(domain: "RecorderPlayer", code: 5, userInfo: [NSLocalizedDescriptionKey: "No paused recording to resume"])
+        }
+
+        recorder.record()
+        recordingStatus = .recording
+        notifyRecordingStatusChange()
+    }
+
+    @objc public func preparePlay(path: String) throws -> (playerId: String, duration: Int) {
+        // Use Application Support directory + bundle identifier (matches Capacitor's Directory.Data)
+        let appSupportDir = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        let dataDir = appSupportDir.appendingPathComponent(Bundle.main.bundleIdentifier ?? "")
+        let url = dataDir.appendingPathComponent(path)
+
+        guard FileManager.default.fileExists(atPath: url.path) else {
+            throw NSError(domain: "RecorderPlayer", code: 6, userInfo: [NSLocalizedDescriptionKey: "Audio file not found at path: \(path)"])
+        }
+
+        do {
+            let audioPlayer = try AVAudioPlayer(contentsOf: url)
+            audioPlayer.prepareToPlay()
+
+            let playerId = generatePlayerId()
+            let playerState = PlayerState(playerId: playerId, audioPlayer: audioPlayer)
+            playerState.delegate = delegate
+            players[playerId] = playerState
+
+            let duration = Int(audioPlayer.duration * 1000)
+            playerState.notifyStatusChange()
+
+            return (playerId, duration)
+        } catch {
+            throw NSError(domain: "RecorderPlayer", code: 7, userInfo: [NSLocalizedDescriptionKey: "Failed to load audio: \(error.localizedDescription)"])
+        }
+    }
+
+    @objc public func play(playerId: String) throws {
+        guard let playerState = players[playerId] else {
+            throw NSError(domain: "RecorderPlayer", code: 8, userInfo: [NSLocalizedDescriptionKey: "No player found with ID: \(playerId)"])
+        }
+
+        playerState.audioPlayer.play()
+        playerState.status = .playing
+        playerState.startTimer()
+        playerState.notifyStatusChange()
+    }
+
+    @objc public func pausePlay(playerId: String) throws {
+        guard let playerState = players[playerId] else {
+            throw NSError(domain: "RecorderPlayer", code: 9, userInfo: [NSLocalizedDescriptionKey: "No player found with ID: \(playerId)"])
+        }
+
+        guard playerState.status == .playing else {
+            throw NSError(domain: "RecorderPlayer", code: 9, userInfo: [NSLocalizedDescriptionKey: "No audio playing to pause"])
+        }
+
+        playerState.audioPlayer.pause()
+        playerState.status = .paused
+        playerState.stopTimer()
+        playerState.notifyStatusChange()
+    }
+
+    @objc public func resumePlay(playerId: String) throws {
+        guard let playerState = players[playerId] else {
+            throw NSError(domain: "RecorderPlayer", code: 10, userInfo: [NSLocalizedDescriptionKey: "No player found with ID: \(playerId)"])
+        }
+
+        guard playerState.status == .paused else {
+            throw NSError(domain: "RecorderPlayer", code: 10, userInfo: [NSLocalizedDescriptionKey: "No paused audio to resume"])
+        }
+
+        playerState.audioPlayer.play()
+        playerState.status = .playing
+        playerState.startTimer()
+        playerState.notifyStatusChange()
+    }
+
+    @objc public func stopPlay(playerId: String) throws {
+        guard let playerState = players[playerId] else {
+            throw NSError(domain: "RecorderPlayer", code: 11, userInfo: [NSLocalizedDescriptionKey: "No player found with ID: \(playerId)"])
+        }
+
+        playerState.audioPlayer.stop()
+        playerState.audioPlayer.currentTime = 0
+        playerState.status = .stopped
+        playerState.stopTimer()
+        playerState.notifyStatusChange()
+    }
+
+    @objc public func seekTo(playerId: String, position: Int) throws {
+        guard let playerState = players[playerId] else {
+            throw NSError(domain: "RecorderPlayer", code: 12, userInfo: [NSLocalizedDescriptionKey: "No player found with ID: \(playerId)"])
+        }
+
+        let positionInSeconds = TimeInterval(position) / 1000.0
+        guard positionInSeconds >= 0 && positionInSeconds <= playerState.audioPlayer.duration else {
+            throw NSError(domain: "RecorderPlayer", code: 13, userInfo: [NSLocalizedDescriptionKey: "Invalid seek position"])
+        }
+
+        playerState.audioPlayer.currentTime = positionInSeconds
+        playerState.notifyStatusChange()
+    }
+
+    @objc public func getPlaybackStatus(playerId: String) -> (status: String, currentPosition: Int, duration: Int)? {
+        guard let playerState = players[playerId] else {
+            return nil
+        }
+
+        let currentPosition = Int(playerState.audioPlayer.currentTime * 1000)
+        let duration = Int(playerState.audioPlayer.duration * 1000)
+        return (playerState.status.rawValue, currentPosition, duration)
+    }
+
+    @objc public func getRecordingStatus() -> (status: String, duration: Int) {
+        var duration = 0
+        if let recorder = audioRecorder {
+            duration = Int(recorder.currentTime * 1000)
+        }
+        return (recordingStatus.rawValue, duration)
+    }
+
+    @objc public func destroyPlayer(playerId: String) {
+        guard let playerState = players[playerId] else {
+            return
+        }
+
+        playerState.audioPlayer.stop()
+        playerState.stopTimer()
+        players.removeValue(forKey: playerId)
+    }
+
+    private func notifyRecordingStatusChange() {
+        let status = getRecordingStatus()
+        delegate?.onRecordingStatusChange(status: recordingStatus, duration: status.duration)
+    }
+}

package/ios/Sources/RecorderPlayerPlugin/RecorderPlayerPlugin.swift

@@ -0,0 +1,249 @@
+import Foundation
+import Capacitor
+import AVFoundation
+
+@objc(RecorderPlayerPlugin)
+public class RecorderPlayerPlugin: CAPPlugin, CAPBridgedPlugin, RecorderPlayerDelegate {
+    public let identifier = "RecorderPlayerPlugin"
+    public let jsName = "RecorderPlayer"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "requestPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startRecord", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopRecord", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "pauseRecord", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "resumeRecord", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "preparePlay", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "play", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "pausePlay", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "resumePlay", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopPlay", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "seekTo", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPlaybackStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getRecordingStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "destroyPlayer", returnType: CAPPluginReturnPromise)
+    ]
+
+    private lazy var implementation: RecorderPlayer = {
+        let recorder = RecorderPlayer()
+        recorder.delegate = self
+        return recorder
+    }()
+
+    @objc func requestPermission(_ call: CAPPluginCall) {
+        AVAudioSession.sharedInstance().requestRecordPermission { granted in
+            DispatchQueue.main.async {
+                call.resolve([
+                    "microphone": granted ? "granted" : "denied"
+                ])
+            }
+        }
+    }
+
+    @objc func checkPermission(_ call: CAPPluginCall) {
+        let status = AVAudioSession.sharedInstance().recordPermission
+        var permissionStatus: String
+
+        switch status {
+        case .granted:
+            permissionStatus = "granted"
+        case .denied:
+            permissionStatus = "denied"
+        case .undetermined:
+            permissionStatus = "prompt"
+        @unknown default:
+            permissionStatus = "prompt"
+        }
+
+        call.resolve([
+            "microphone": permissionStatus
+        ])
+    }
+
+    @objc func startRecord(_ call: CAPPluginCall) {
+        let path = call.getString("path")
+        do {
+            try implementation.startRecord(path: path)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func stopRecord(_ call: CAPPluginCall) {
+        do {
+            let result = try implementation.stopRecord()
+            call.resolve([
+                "path": result.path,
+                "duration": result.duration
+            ])
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func pauseRecord(_ call: CAPPluginCall) {
+        do {
+            try implementation.pauseRecord()
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func resumeRecord(_ call: CAPPluginCall) {
+        do {
+            try implementation.resumeRecord()
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func preparePlay(_ call: CAPPluginCall) {
+        guard let path = call.getString("path") else {
+            call.reject("Path is required")
+            return
+        }
+
+        do {
+            let result = try implementation.preparePlay(path: path)
+            call.resolve([
+                "playerId": result.playerId,
+                "duration": result.duration
+            ])
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func play(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        do {
+            try implementation.play(playerId: playerId)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func pausePlay(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        do {
+            try implementation.pausePlay(playerId: playerId)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func resumePlay(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        do {
+            try implementation.resumePlay(playerId: playerId)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func stopPlay(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        do {
+            try implementation.stopPlay(playerId: playerId)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func seekTo(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        guard let position = call.getInt("position") else {
+            call.reject("Position is required")
+            return
+        }
+
+        do {
+            try implementation.seekTo(playerId: playerId, position: position)
+            call.resolve()
+        } catch {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func getPlaybackStatus(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        guard let status = implementation.getPlaybackStatus(playerId: playerId) else {
+            call.reject("No player found with ID: \(playerId)")
+            return
+        }
+
+        call.resolve([
+            "playerId": playerId,
+            "status": status.status,
+            "currentPosition": status.currentPosition,
+            "duration": status.duration
+        ])
+    }
+
+    @objc func getRecordingStatus(_ call: CAPPluginCall) {
+        let status = implementation.getRecordingStatus()
+        call.resolve([
+            "status": status.status,
+            "duration": status.duration
+        ])
+    }
+
+    @objc func destroyPlayer(_ call: CAPPluginCall) {
+        guard let playerId = call.getString("playerId") else {
+            call.reject("playerId is required")
+            return
+        }
+
+        implementation.destroyPlayer(playerId: playerId)
+        call.resolve()
+    }
+
+    // MARK: - RecorderPlayerDelegate
+
+    public func onRecordingStatusChange(status: RecordingStatus, duration: Int) {
+        notifyListeners("recordingStatusChange", data: [
+            "status": status.rawValue,
+            "duration": duration
+        ])
+    }
+
+    public func onPlaybackStatusChange(playerId: String, status: PlaybackStatus, currentPosition: Int, duration: Int) {
+        notifyListeners("playbackStatusChange", data: [
+            "playerId": playerId,
+            "status": status.rawValue,
+            "currentPosition": currentPosition,
+            "duration": duration
+        ])
+    }
+}

package/ios/Tests/RecorderPlayerPluginTests/RecorderPlayerTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import RecorderPlayerPlugin
+
+class RecorderPlayerTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = RecorderPlayer()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@scr2em/capacitor-plugin-recorder",
+  "version": "0.0.1",
+  "description": "ee",
+  "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/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorPluginRecorder.podspec"
+  ],
+  "author": "me",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com.git"
+  },
+  "bugs": {
+    "url": "https://github.com/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapacitorPluginRecorder -destination generic/platform=iOS",
+    "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}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api RecorderPlayerPlugin --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",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.1",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.1",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.7",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.53.2",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}