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

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,9 +1,11 @@
 import Foundation
 
+/// Represents the current recording state.
 enum CurrentRecordingStatus: String {
 
     case RECORDING
     case PAUSED
+    case INTERRUPTED
     case NONE
 
 }

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"
@@ -7,6 +8,7 @@ struct Messages {
     static let FAILED_TO_RECORD = "FAILED_TO_RECORD"
     static let RECORDING_HAS_NOT_STARTED = "RECORDING_HAS_NOT_STARTED"
     static let FAILED_TO_FETCH_RECORDING = "FAILED_TO_FETCH_RECORDING"
+    static let FAILED_TO_MERGE_RECORDING = "FAILED_TO_MERGE_RECORDING"
     static let EMPTY_RECORDING = "EMPTY_RECORDING"
     static let ALREADY_RECORDING = "ALREADY_RECORDING"
     static let MICROPHONE_BEING_USED = "MICROPHONE_BEING_USED"

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/Platform/CustomMediaRecorder.swift

@@ -0,0 +1,359 @@
+import Foundation
+import AVFoundation
+
+/// AVAudioRecorder wrapper that supports interruptions and segment merging.
+class CustomMediaRecorder: RecorderAdapter {
+
+    /// Options provided by the service layer.
+    public var options: RecordOptions?
+    /// Active audio session for recording.
+    private var recordingSession: AVAudioSession!
+    /// Active recorder instance for the current segment.
+    private var audioRecorder: AVAudioRecorder!
+    /// 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)?
+
+    /// Recorder settings used for all segments.
+    private let settings = [
+        AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
+        AVSampleRateKey: 44100,
+        AVNumberOfChannelsKey: 1,
+        AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
+    ]
+
+    /// Resolves the directory where audio files should be saved.
+    private func getDirectoryToSaveAudioFile() -> URL {
+	if options?.directory != nil,
+	   let directory = getDirectory(directory: options?.directory),
+           var outputDirURL = FileManager.default.urls(for: directory, in: .userDomainMask).first {
+            if let subDirectory = options?.subDirectory?.trimmingCharacters(in: CharacterSet(charactersIn: "/")) {
+                outputDirURL = outputDirURL.appendingPathComponent(subDirectory, isDirectory: true)
+
+                do {
+                    if !FileManager.default.fileExists(atPath: outputDirURL.path) {
+                        try FileManager.default.createDirectory(at: outputDirURL, withIntermediateDirectories: true)
+                    }
+                } catch {
+                    print("Error creating directory: \(error)")
+                }
+            }
+
+            return outputDirURL
+        }
+
+        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()
+            originalRecordingSessionCategory = recordingSession.category
+            try recordingSession.setCategory(AVAudioSession.Category.playAndRecord)
+            try recordingSession.setActive(true)
+            baseAudioFilePath = getDirectoryToSaveAudioFile().appendingPathComponent("recording-\(Int(Date().timeIntervalSince1970 * 1000)).aac")
+            audioFileSegments = [baseAudioFilePath]
+            audioRecorder = try AVAudioRecorder(url: baseAudioFilePath, settings: settings)
+            setupInterruptionHandling()
+            audioRecorder.record()
+            status = CurrentRecordingStatus.RECORDING
+            return true
+        } catch {
+            return false
+        }
+    }
+
+    /// Stops recording and merges segments if needed.
+    public func stopRecording(completion: @escaping (Bool) -> Void) {
+        removeInterruptionHandling()
+        audioRecorder.stop()
+
+        let finalizeStop: (Bool) -> Void = { [weak self] success in
+            guard let self = self else {
+                completion(false)
+                return
+            }
+
+            do {
+                try self.recordingSession.setActive(false)
+                try self.recordingSession.setCategory(self.originalRecordingSessionCategory)
+            } catch {
+            }
+
+            self.originalRecordingSessionCategory = nil
+            self.audioRecorder = nil
+            self.recordingSession = nil
+            self.status = CurrentRecordingStatus.NONE
+            completion(success)
+        }
+
+        if audioFileSegments.count > 1 {
+            DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+                guard let self = self else {
+                    completion(false)
+                    return
+                }
+                self.mergeAudioSegments { success in
+                    finalizeStop(success)
+                }
+            }
+        } else {
+            finalizeStop(true)
+        }
+    }
+
+    /// 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 {
+            case "CACHE":
+                return .cachesDirectory
+            case "LIBRARY":
+                return .libraryDirectory
+            default:
+                return .documentDirectory
+            }
+        }
+        return nil
+    }
+
+    /// Pauses recording when currently active.
+    public func pauseRecording() -> Bool {
+        if(status == CurrentRecordingStatus.RECORDING) {
+            audioRecorder.pause()
+            status = CurrentRecordingStatus.PAUSED
+            return true
+        } else {
+            return false
+        }
+    }
+
+    /// 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)
+                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)
+                    audioFileSegments.append(segmentPath)
+                }
+                audioRecorder.record()
+                status = CurrentRecordingStatus.RECORDING
+                return true
+            } catch {
+                if wasInterrupted {
+                    try? recordingSession.setActive(false)
+                }
+                return false
+            }
+        }
+
+        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(),
+            queue: .main
+        ) { [weak self] notification in
+            self?.handleInterruption(notification: notification)
+        }
+    }
+
+    /// Removes interruption observers.
+    private func removeInterruptionHandling() {
+        if let observer = interruptionObserver {
+            NotificationCenter.default.removeObserver(observer)
+            interruptionObserver = nil
+        }
+    }
+
+    /// Handles audio session interruptions.
+    private func handleInterruption(notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let interruptionTypeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
+              let interruptionType = AVAudioSession.InterruptionType(rawValue: interruptionTypeValue) else {
+            return
+        }
+
+        switch interruptionType {
+        case .began:
+            if status == CurrentRecordingStatus.RECORDING {
+                audioRecorder.stop()
+                status = CurrentRecordingStatus.INTERRUPTED
+                onInterruptionBegan?()
+            }
+
+        case .ended:
+            if status == CurrentRecordingStatus.INTERRUPTED {
+                onInterruptionEnded?()
+            }
+
+        @unknown default:
+            break
+        }
+    }
+
+    /// Merges recorded segments into a single file when interruptions occur.
+    private func mergeAudioSegments(completion: @escaping (Bool) -> Void) {
+        if audioFileSegments.count <= 1 {
+            completion(true)
+            return
+        }
+
+        let basePathWithoutExtension = baseAudioFilePath.deletingPathExtension()
+        let mergedFilePath = basePathWithoutExtension.appendingPathExtension("m4a")
+        let segmentURLs = audioFileSegments
+        let keys = ["tracks", "duration"]
+        let dispatchGroup = DispatchGroup()
+        let syncQueue = DispatchQueue(label: "CustomMediaRecorder.assetSyncQueue")
+        var loadedAssets = Array<AVURLAsset?>(repeating: nil, count: segmentURLs.count)
+        var loadFailed = false
+
+        for (index, segmentURL) in segmentURLs.enumerated() {
+            let asset = AVURLAsset(url: segmentURL)
+            dispatchGroup.enter()
+            asset.loadValuesAsynchronously(forKeys: keys) {
+                var assetIsValid = true
+                for key in keys {
+                    var error: NSError?
+                    if asset.statusOfValue(forKey: key, error: &error) != .loaded {
+                        assetIsValid = false
+                        break
+                    }
+                }
+                syncQueue.async {
+                    if assetIsValid {
+                        loadedAssets[index] = asset
+                    } else {
+                        loadFailed = true
+                    }
+                    dispatchGroup.leave()
+                }
+            }
+        }
+
+        dispatchGroup.notify(queue: DispatchQueue.global(qos: .userInitiated)) { [weak self] in
+            guard let self = self else {
+                completion(false)
+                return
+            }
+
+            var assets: [AVURLAsset] = []
+            var didFail = false
+            syncQueue.sync {
+                if loadFailed || loadedAssets.contains(where: { $0 == nil }) {
+                    didFail = true
+                } else {
+                    assets = loadedAssets.compactMap { $0 }
+                }
+            }
+
+            if didFail || assets.count != segmentURLs.count {
+                completion(false)
+                return
+            }
+
+            let composition = AVMutableComposition()
+            guard let compositionAudioTrack = composition.addMutableTrack(
+                withMediaType: .audio,
+                preferredTrackID: kCMPersistentTrackID_Invalid
+            ) else {
+                completion(false)
+                return
+            }
+
+            var insertTime = CMTime.zero
+
+            for asset in assets {
+                guard let assetTrack = asset.tracks(withMediaType: .audio).first else {
+                    completion(false)
+                    return
+                }
+
+                do {
+                    let timeRange = CMTimeRange(start: .zero, duration: asset.duration)
+                    try compositionAudioTrack.insertTimeRange(timeRange, of: assetTrack, at: insertTime)
+                    insertTime = CMTimeAdd(insertTime, asset.duration)
+                } catch {
+                    completion(false)
+                    return
+                }
+            }
+
+            guard let exportSession = AVAssetExportSession(asset: composition, presetName: AVAssetExportPresetAppleM4A) else {
+                completion(false)
+                return
+            }
+
+            let tempDirectory = self.getDirectoryToSaveAudioFile()
+            let tempPath = tempDirectory.appendingPathComponent("temp-merged-\(Int(Date().timeIntervalSince1970 * 1000)).m4a")
+
+            exportSession.outputURL = tempPath
+            exportSession.outputFileType = .m4a
+
+            exportSession.exportAsynchronously {
+                guard exportSession.status == .completed else {
+                    completion(false)
+                    return
+                }
+
+                if !FileManager.default.fileExists(atPath: tempPath.path) {
+                    completion(false)
+                    return
+                }
+
+                do {
+                    if FileManager.default.fileExists(atPath: mergedFilePath.path) {
+                        try FileManager.default.removeItem(at: mergedFilePath)
+                    }
+                    try FileManager.default.moveItem(at: tempPath, to: mergedFilePath)
+
+                    for segmentURL in self.audioFileSegments {
+                        if segmentURL != mergedFilePath && FileManager.default.fileExists(atPath: segmentURL.path) {
+                            try? FileManager.default.removeItem(at: segmentURL)
+                        }
+                    }
+                    self.baseAudioFilePath = mergedFilePath
+                    completion(true)
+                } catch {
+                    if FileManager.default.fileExists(atPath: tempPath.path) {
+                        try? FileManager.default.removeItem(at: tempPath)
+                    }
+                    completion(false)
+                }
+            }
+        }
+    }
+
+}