rns-recplay 2.0.3 → 3.0.0

package/ios/RecPlayModule.swift

@@ -9,18 +9,26 @@ class RecPlayModule: RCTEventEmitter {
     private var playerItem: AVPlayerItem?
     private var timeObserverToken: Any?
     private var recordingTimer: Timer?
-    private var secondsElapsed = 0
+
     private var isPaused = false
     private var isLooping = false
 
+    private var secondsElapsed: Double = 0
+    private var recordingStartTime: Date?
+    private var timeAccumulatedBeforePause: Double = 0
+
     override static func requiresMainQueueSetup() -> Bool {
         return true
     }
 
     override func supportedEvents() -> [String]! {
         return [
-            "onTimerUpdate", "onPlaybackStatus", "onPlaybackProgress", "onPlaybackFinished",
+            "onTimerUpdate",
+            "onPlaybackStatus",
+            "onPlaybackProgress",
+            "onPlaybackFinished",
             "onAudioInterruption",
+            "onVolumeUpdate",
         ]
     }
 
@@ -45,64 +53,104 @@ class RecPlayModule: RCTEventEmitter {
     }
 
     // MARK: - Recording Logic
-    @objc(startRecording:shouldStopPlayback:duck:mixWithOthers:resolver:rejecter:)
-    func startRecording(
-        fileName: String?,
-        shouldStopPlayback: Bool,
-        duck: Bool,
-        mixWithOthers: Bool,
-        resolve: @escaping RCTPromiseResolveBlock,
-        reject: @escaping RCTPromiseRejectBlock
-    ) {
-        if shouldStopPlayback {
-            stopPlaybackInternal()
-        }
-        let session = AVAudioSession.sharedInstance()
-        do {
-            var options: AVAudioSession.CategoryOptions = [.defaultToSpeaker]
-            if duck {
-                options.insert(.duckOthers)
-            }
-            if mixWithOthers {
-                options.insert(.mixWithOthers)
-            }
-            
-            // Fix: Don't deactivate the session before changing category if WebRTC is active
-            try session.setCategory(.playAndRecord, mode: .default, options: options)
-            try session.setActive(true)
-
-            let name = fileName ?? "rec_\(Int(Date().timeIntervalSince1970))"
-            let fileURL = FileManager.default.temporaryDirectory
-                .appendingPathComponent("\(name).m4a")
-            let settings: [String: Any] = [
-                AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
-                AVSampleRateKey: 44100,
-                AVNumberOfChannelsKey: 1,
-                AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
-                AVEncoderBitRateKey: 128000,
-            ]
-            audioRecorder = try AVAudioRecorder(url: fileURL, settings: settings)
-            audioRecorder?.prepareToRecord()
-            audioRecorder?.record()
-            secondsElapsed = 0
-            isPaused = false
-            DispatchQueue.main.async {
-                self.recordingTimer?.invalidate()
-                self.recordingTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) {
-                    _ in
-                    if !self.isPaused {
-                        self.sendEvent(
-                            withName: "onTimerUpdate",
-                            body: ["seconds": self.secondsElapsed]
-                        )
-                        self.secondsElapsed += 1
-                    }
+
+    @objc(startRecording:shouldStopPlayback:duck:mixWithOthers:useBT:resolver:rejecter:)
+        func startRecording(
+            fileName: String?,
+            shouldStopPlayback: Bool,
+            duck: Bool,
+            mixWithOthers: Bool,
+            useBT: Bool,
+            resolve: @escaping RCTPromiseResolveBlock,
+            reject: @escaping RCTPromiseRejectBlock
+        ) {
+            if shouldStopPlayback { stopPlaybackInternal() }
+
+            let session = AVAudioSession.sharedInstance()
+
+            do {
+                /* ✅ THE FIX FOR "LIGHTNING-BLUETOOTH" HEADPHONES:
+                   We ONLY allow .allowBluetoothA2DP.
+                   We EXPLICITLY do NOT include .allowBluetoothHFP.
+                   
+                   This keeps those "Fake Lightning" headphones in high-quality mode.
+                   Because HFP is disabled, iOS is FORCED to use the phone's built-in mic.
+                */
+                var options: AVAudioSession.CategoryOptions = [.defaultToSpeaker, .allowBluetoothA2DP]
+
+                if duck { options.insert(.duckOthers) }
+                if mixWithOthers { options.insert(.mixWithOthers) }
+
+                // Use .measurement to keep the signal raw and avoid the "ducking" effect
+                try session.setCategory(.playAndRecord, mode: .videoRecording, options: options)
+                try session.setActive(true)
+
+                // Force the Built-in Mic again just to be safe
+                if let builtInMic = session.availableInputs?.first(where: { $0.portType == .builtInMic }) {
+                    try session.setPreferredInput(builtInMic)
                 }
+
+                let rawName = fileName ?? "rec_\(Int(Date().timeIntervalSince1970))"
+                let baseName = (rawName as NSString).deletingPathExtension
+                let fileURL = FileManager.default.temporaryDirectory.appendingPathComponent(baseName).appendingPathExtension("m4a")
+
+                let settings: [String: Any] = [
+                    AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
+                    AVSampleRateKey: 44100,
+                    AVNumberOfChannelsKey: 1,
+                    AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
+                    AVEncoderBitRateKey: 128000,
+                ]
+
+                audioRecorder = try AVAudioRecorder(url: fileURL, settings: settings)
+                audioRecorder?.isMeteringEnabled = true
+                audioRecorder?.prepareToRecord()
+                audioRecorder?.record()
+
+                self.secondsElapsed = 0
+                self.timeAccumulatedBeforePause = 0
+                self.recordingStartTime = Date()
+                self.isPaused = false
+
+                DispatchQueue.main.async { self.startTimer() }
+                resolve(baseName)
+
+            } catch {
+                reject("REC_ERROR", "Failed to start recording", error)
             }
+        }
 
-            resolve(name)
-        } catch {
-            reject("REC_ERROR", "Failed to start recording", error)
+    private func startTimer() {
+        recordingTimer?.invalidate()
+
+        recordingTimer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) {
+            [weak self] _ in
+            guard let self = self, let recorder = self.audioRecorder, !self.isPaused else { return }
+
+            recorder.updateMeters()
+            let db = recorder.averagePower(forChannel: 0)
+            let normalizedVolume = max(0, (db + 60) / 60)
+
+            self.sendEvent(
+                withName: "onVolumeUpdate",
+                body: [
+                    "value": db,
+                    "normalized": normalizedVolume,
+                ])
+
+            if let startTime = self.recordingStartTime {
+                let sessionDuration = Date().timeIntervalSince(startTime)
+                let totalCurrentElapsed = self.timeAccumulatedBeforePause + sessionDuration
+
+                let oldSecond = Int(floor(self.secondsElapsed))
+                let newSecond = Int(floor(totalCurrentElapsed))
+
+                if newSecond > oldSecond {
+                    self.sendEvent(withName: "onTimerUpdate", body: ["seconds": newSecond])
+                }
+
+                self.secondsElapsed = totalCurrentElapsed
+            }
         }
     }
 
@@ -111,16 +159,20 @@ class RecPlayModule: RCTEventEmitter {
         resolve: @escaping RCTPromiseResolveBlock,
         reject: @escaping RCTPromiseRejectBlock
     ) {
+        let finalDuration = secondsElapsed
+
         recordingTimer?.invalidate()
         recordingTimer = nil
+
         audioRecorder?.stop()
         let url = audioRecorder?.url
         audioRecorder = nil
-        
-        // Fix: Removed setActive(false) to prevent killing WebRTC streams
-        
+
         if let fileUrl = url {
-            resolve(fileUrl.absoluteString)
+            resolve([
+                "uri": fileUrl.absoluteString,
+                "duration": finalDuration,
+            ])
         } else {
             reject("STOP_ERROR", "No recording found", nil)
         }
@@ -128,111 +180,129 @@ class RecPlayModule: RCTEventEmitter {
 
     @objc(pauseRecording:rejecter:)
     func pauseRecording(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        audioRecorder?.pause()
-        isPaused = true
+        if !isPaused {
+            audioRecorder?.pause()
+            // Save the work done so far
+            if let startTime = recordingStartTime {
+                timeAccumulatedBeforePause += Date().timeIntervalSince(startTime)
+            }
+            recordingStartTime = nil
+            isPaused = true
+        }
         resolve(true)
     }
 
     @objc(resumeRecording:rejecter:)
     func resumeRecording(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
-        audioRecorder?.record()
-        isPaused = false
+        if isPaused {
+            // Set a new reference start time for this segment
+            recordingStartTime = Date()
+            audioRecorder?.record()
+            isPaused = false
+        }
         resolve(true)
     }
 
     // MARK: - Permissions
     @objc(checkPermission:rejecter:)
     func checkPermission(
-        resolve: @escaping RCTPromiseResolveBlock,
-        reject: @escaping RCTPromiseRejectBlock
+        resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock
     ) {
         let status = AVAudioSession.sharedInstance().recordPermission
         switch status {
-        case .granted:
-            resolve("granted")
-        case .denied:
-            resolve("blocked")
-        case .undetermined:
-            resolve("denied")
-        @unknown default:
-            resolve("unavailable")
+        case .granted: resolve("granted")
+        case .denied: resolve("blocked")
+        case .undetermined: resolve("denied")
+        @unknown default: resolve("unavailable")
         }
     }
 
     @objc(requestPermission:rejecter:)
     func requestPermission(
-        resolve: @escaping RCTPromiseResolveBlock,
-        reject: @escaping RCTPromiseRejectBlock
+        resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock
     ) {
         AVAudioSession.sharedInstance().requestRecordPermission { granted in
             resolve(granted ? "granted" : "blocked")
         }
     }
 
-    // MARK: - Playback Logic (UPDATED for WebRTC Compatibility)
-    @objc(playAudio:shouldStopPrevious:loop:mixWithOthers:duckOthers:)
+    // MARK: - Playback Logic
+@objc(playAudio:shouldStopPrevious:loop:mixWithOthers:duckOthers:)
     func playAudio(
-        uri: String,
-        shouldStopPrevious: Bool,
-        loop: Bool,
-        mixWithOthers: Bool,
-        duckOthers: Bool
+        uri: String, shouldStopPrevious: Bool, loop: Bool, mixWithOthers: Bool, duckOthers: Bool
     ) {
         DispatchQueue.main.async { [weak self] in
             guard let self = self else { return }
-            if shouldStopPrevious {
-                self.stopPlaybackInternal()
-            }
+            if shouldStopPrevious { self.stopPlaybackInternal() }
+
             let session = AVAudioSession.sharedInstance()
             do {
-                // Fix: Removed setActive(false)
-                var options: AVAudioSession.CategoryOptions = []
+                var options: AVAudioSession.CategoryOptions = [
+                    .allowBluetoothHFP, .allowBluetoothA2DP, .defaultToSpeaker,
+                ]
                 if mixWithOthers {
                     options.insert(.mixWithOthers)
                 } else if duckOthers {
                     options.insert(.duckOthers)
                 }
-                
-                // Fix: If WebRTC is currently recording/calling, don't force .playback category
-                // This keeps the microphone open.
+
                 if session.category != .playAndRecord {
-                    try session.setCategory(.playback, mode: .default, options: options)
+                    try session.setCategory(.playback, mode: .moviePlayback, options: options)
+                } else {
+                    try session.setCategory(.playAndRecord, mode: .videoRecording, options: options)
                 }
-                
                 try session.setActive(true)
+                
+                if session.category == .playAndRecord {
+                    if let builtInMic = session.availableInputs?.first(where: {
+                        $0.portType == .builtInMic
+                    }) {
+                        try? session.setPreferredInput(builtInMic)
+                    }
+                }
+                
             } catch {
                 print("⚠️ Audio Session Error: \(error.localizedDescription)")
             }
-            let url: URL
-            if uri.hasPrefix("http") || uri.hasPrefix("file://") {
-                guard let u = URL(string: uri) else {
-                    self.sendEvent(withName: "onPlaybackStatus", body: ["status": "ERROR"])
-                    return
-                }
-                url = u
+
+            // --- LITERAL PATH LOGIC (Matching the Mixer) ---
+            var url: URL?
+            if uri.hasPrefix("http") {
+                url = URL(string: uri)
             } else {
-                url = URL(fileURLWithPath: uri)
+                // Remove the scheme to get the literal path string
+                let literalPath = uri.replacingOccurrences(of: "file://", with: "")
+                
+                // Use fileURLWithPath to handle literal spaces and % symbols on disk
+                url = URL(fileURLWithPath: literalPath)
             }
-            let asset = AVURLAsset(url: url)
+
+            guard let validUrl = url else {
+                print("❌ Playback Failed: Could not resolve URL for \(uri)")
+                self.sendEvent(withName: "onPlaybackStatus", body: ["status": "ERROR"])
+                return
+            }
+
+            let asset = AVURLAsset(url: validUrl)
             self.playerItem = AVPlayerItem(asset: asset)
             self.isLooping = loop
-            
+
             self.playerItem?.addObserver(self, forKeyPath: "status", options: [.new], context: nil)
             self.playerItem?.addObserver(
                 self, forKeyPath: "playbackBufferEmpty", options: [.new], context: nil)
             self.playerItem?.addObserver(
                 self, forKeyPath: "playbackLikelyToKeepUp", options: [.new], context: nil)
+
             NotificationCenter.default.addObserver(
-                self,
-                selector: #selector(self.playerDidFinishPlaying),
-                name: .AVPlayerItemDidPlayToEndTime,
-                object: self.playerItem
-            )
+                self, selector: #selector(self.playerDidFinishPlaying),
+                name: .AVPlayerItemDidPlayToEndTime, object: self.playerItem)
+
             if self.audioPlayer == nil {
                 self.audioPlayer = AVPlayer(playerItem: self.playerItem)
             } else {
                 self.audioPlayer?.replaceCurrentItem(with: self.playerItem)
             }
+
             self.setupProgressObserver()
             self.audioPlayer?.play()
             self.sendEvent(withName: "onPlaybackStatus", body: ["status": "PLAYING"])
@@ -240,38 +310,27 @@ class RecPlayModule: RCTEventEmitter {
     }
 
     override func observeValue(
-        forKeyPath keyPath: String?,
-        of object: Any?,
-        change: [NSKeyValueChangeKey: Any]?,
+        forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?,
         context: UnsafeMutableRawPointer?
     ) {
         guard let item = object as? AVPlayerItem else { return }
         switch keyPath {
         case "status":
-            switch item.status {
-            case .readyToPlay:
+            if item.status == .readyToPlay {
                 let isPlaying = self.audioPlayer?.timeControlStatus == .playing
                 self.sendEvent(
                     withName: "onPlaybackStatus", body: ["status": isPlaying ? "PLAYING" : "PAUSED"]
                 )
-            case .failed:
+            } else if item.status == .failed {
                 self.sendEvent(withName: "onPlaybackStatus", body: ["status": "ERROR"])
-            default:
-                self.sendEvent(withName: "onPlaybackStatus", body: ["status": "IDLE"])
-            }
-        case "playbackBufferEmpty":
-            if item.isPlaybackBufferEmpty {
-                self.sendEvent(withName: "onPlaybackStatus", body: ["status": "BUFFERING"])
-            }
-        case "playbackLikelyToKeepUp":
-            if item.isPlaybackLikelyToKeepUp {
-                let isPlaying = self.audioPlayer?.timeControlStatus == .playing
-                self.sendEvent(
-                    withName: "onPlaybackStatus", body: ["status": isPlaying ? "PLAYING" : "PAUSED"]
-                )
             }
-        default:
-            break
+        case "playbackBufferEmpty" where item.isPlaybackBufferEmpty:
+            self.sendEvent(withName: "onPlaybackStatus", body: ["status": "BUFFERING"])
+        case "playbackLikelyToKeepUp" where item.isPlaybackLikelyToKeepUp:
+            let isPlaying = self.audioPlayer?.timeControlStatus == .playing
+            self.sendEvent(
+                withName: "onPlaybackStatus", body: ["status": isPlaying ? "PLAYING" : "PAUSED"])
+        default: break
         }
     }
 
@@ -279,43 +338,41 @@ class RecPlayModule: RCTEventEmitter {
         if isLooping {
             audioPlayer?.seek(to: .zero)
             audioPlayer?.play()
-            self.sendEvent(withName: "onPlaybackStatus", body: ["status": "PLAYING"])
         } else {
             sendEvent(withName: "onPlaybackFinished", body: ["finished": true])
             sendEvent(withName: "onPlaybackStatus", body: ["status": "ENDED"])
-            // Fix: Removed setActive(false) to keep WebRTC alive
         }
     }
 
     private func setupProgressObserver() {
-        if let token = timeObserverToken {
-            audioPlayer?.removeTimeObserver(token)
-        }
-        let interval = CMTime(seconds: 0.5, preferredTimescale: 1000)
+        if let token = timeObserverToken { audioPlayer?.removeTimeObserver(token) }
+
+        // Update every 50ms for smooth UI and accurate end-handle stopping
+        let interval = CMTime(seconds: 0.05, preferredTimescale: 1000)
+
         timeObserverToken = audioPlayer?.addPeriodicTimeObserver(
-            forInterval: interval,
-            queue: .main
+            forInterval: interval, queue: .main
         ) { [weak self] time in
-            guard
-                let self = self,
-                let duration = self.audioPlayer?.currentItem?.duration.seconds,
-                duration > 0,
-                !duration.isNaN
+            guard let self = self,
+                let currentItem = self.audioPlayer?.currentItem,
+                currentItem.status == .readyToPlay
             else { return }
+
+            let duration = currentItem.duration.seconds
+            guard !duration.isNaN else { return }
+
             self.sendEvent(
                 withName: "onPlaybackProgress",
                 body: [
                     "currentPosition": time.seconds,
                     "duration": duration,
-                ]
-            )
+                ])
         }
     }
 
     @objc(stopPlayback:rejecter:)
     func stopPlayback(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
         stopPlaybackInternal()
-        // Fix: Removed setActive(false)
         resolve(true)
     }
 
@@ -331,20 +388,28 @@ class RecPlayModule: RCTEventEmitter {
             item.removeObserver(self, forKeyPath: "playbackBufferEmpty")
             item.removeObserver(self, forKeyPath: "playbackLikelyToKeepUp")
             NotificationCenter.default.removeObserver(
-                self,
-                name: .AVPlayerItemDidPlayToEndTime,
-                object: item
-            )
+                self, name: .AVPlayerItemDidPlayToEndTime, object: item)
         }
         playerItem = nil
     }
 
     @objc(seekTo:)
-    func seekTo(seconds: Double) {
-        let time = CMTime(seconds: seconds, preferredTimescale: 1000)
-        audioPlayer?.seek(to: time)
-    }
+        func seekTo(seconds: Double) {
+            guard let player = audioPlayer else { return }
+
+            // Use a high timescale for precision (60,000 is standard for high-res audio)
+            let time = CMTime(seconds: seconds, preferredTimescale: 60000)
 
+            // ZERO tolerance ensures it lands exactly on the requested sample
+            player.seek(to: time, toleranceBefore: .zero, toleranceAfter: .zero) { finished in
+                if finished {
+                    // 'self' was removed from the capture list because it wasn't being used here.
+                    // If you decide to call a function like self.sendEvent later,
+                    // you should add [weak self] back.
+                    print("🎯 Precision Seek Finished to: \(seconds)")
+                }
+            }
+        }
     @objc(togglePlayback)
     func togglePlayback() {
         if audioPlayer?.timeControlStatus == .playing {
@@ -358,13 +423,11 @@ class RecPlayModule: RCTEventEmitter {
         guard let info = notification.userInfo,
             let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt,
             let type = AVAudioSession.InterruptionType(rawValue: typeValue)
-        else {
-            return
-        }
-        switch type {
-        case .began:
+        else { return }
+
+        if type == .began {
             sendEvent(withName: "onAudioInterruption", body: ["type": "began"])
-        case .ended:
+        } else if type == .ended {
             let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt
             let shouldResume =
                 (optionsValue ?? 0) & AVAudioSession.InterruptionOptions.shouldResume.rawValue != 0
@@ -372,30 +435,37 @@ class RecPlayModule: RCTEventEmitter {
                 withName: "onAudioInterruption",
                 body: ["type": "ended", "shouldResume": shouldResume])
             if shouldResume {
-                do {
-                    try AVAudioSession.sharedInstance().setActive(true)
-                    audioPlayer?.play()
-                } catch {
-                    print("⚠️ Failed to reactivate: \(error.localizedDescription)")
-                }
+                try? AVAudioSession.sharedInstance().setActive(true)
+                audioPlayer?.play()
             }
-        @unknown default:
-            break
         }
     }
 
     @objc private func handleRouteChange(_ notification: Notification) {
+
         guard let userInfo = notification.userInfo,
+
             let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
+
             let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue)
+
         else { return }
+
         switch reason {
+
         case .oldDeviceUnavailable:
+
             print("🔊 Route changed: old device unavailable")
+
         case .newDeviceAvailable:
+
             print("🔊 Route changed: new device available")
+
         default:
+
             break
+
         }
+
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-recplay",
-    "version": "2.0.3",
+    "version": "3.0.0",
     "description": "High-performance React Native module for audio recording and audio playback on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",

package/withNativeRecPlay.js

@@ -33,8 +33,7 @@ const withAndroidPermissions = (config) => {
         // 3. FOREGROUND_SERVICE_MICROPHONE: Required for Android 14+ if recording continues in background.
         const permissionsToAdd = [
             'android.permission.RECORD_AUDIO',
-            'android.permission.MODIFY_AUDIO_SETTINGS',
-            'android.permission.FOREGROUND_SERVICE_MICROPHONE'
+            'android.permission.MODIFY_AUDIO_SETTINGS'
         ];
 
         if (!manifest['uses-permission']) {