rns-recplay 1.3.6 → 1.3.7

package/README.md

@@ -130,12 +130,14 @@ Status Meanings:
 
 ### 🎙️ Recording
 
-#### `startRecording({ fileName?, shouldStopPlayback?, onSecondsUpdate? })`
+#### `startRecording({ fileName?, shouldStopPlayback?, duck?, mixWithOthers?, onSecondsUpdate? })`
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
 | `fileName` | `string` | `null` | Custom `.m4a` file name |
 | `shouldStopPlayback` | `boolean` | `true` | Stops any playing audio |
+| `duck` | `boolean` | `true` | Reduce volume of other audio when recording |
+| `mixWithOthers` | `boolean` | `true` | Mix recording with device playing audio |
 | `onSecondsUpdate` | `function` | `null` | Called every second |
 
 **Returns:** `Promise<string>` (file name)
@@ -200,6 +202,7 @@ Toggles between play and pause.
 - `BUFFERING`
 - `PLAYING`
 - `PAUSED`
+- `ERROR`
 - `ENDED`
 - `IDLE`
 
@@ -217,5 +220,4 @@ Toggles between play and pause.
 
 ## 📄 License
 
-MIT License
-
+MIT License

package/android/src/main/java/com/rnsrecplay/RecPlayModule.kt

@@ -17,6 +17,7 @@ import com.facebook.react.modules.core.PermissionListener
 import com.google.android.exoplayer2.ExoPlayer
 import com.google.android.exoplayer2.MediaItem
 import com.google.android.exoplayer2.Player
+import com.google.android.exoplayer2.audio.AudioAttributes
 import java.io.File
 
 class RecPlayModule(
@@ -214,23 +215,62 @@ class RecPlayModule(
     ) {
         handler.post {
             try {
-                val finalUri =
-                    when {
-                        uriString.startsWith("http://") || uriString.startsWith("https://") -> {
-                            Uri.parse(uriString)
-                        }
-
-                        uriString.startsWith("file://") || uriString.startsWith("content://") -> {
-                            Uri.parse(uriString)
-                        }
-
-                        else -> {
-                            Uri.fromFile(File(uriString))
-                        }
-                    }
-
                 if (player == null) {
                     player = ExoPlayer.Builder(reactContext).build()
+
+                    // ✅ RESTORE PLAYBACK STATUS EVENTS
+                    player?.addListener(
+                        object : Player.Listener {
+                            override fun onPlaybackStateChanged(state: Int) {
+                                val params = Arguments.createMap()
+                                val status =
+                                    when (state) {
+                                        Player.STATE_BUFFERING -> "BUFFERING"
+                                        Player.STATE_READY -> if (player?.isPlaying == true) "PLAYING" else "PAUSED"
+                                        Player.STATE_ENDED -> "ENDED"
+                                        else -> "IDLE"
+                                    }
+
+                                params.putString("status", status)
+                                reactContext
+                                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                    .emit("onPlaybackStatus", params)
+
+                                if (state == Player.STATE_ENDED) {
+                                    playbackHandler.removeCallbacks(playbackRunnable)
+                                    val finishParams = Arguments.createMap()
+                                    finishParams.putBoolean("finished", true)
+                                    reactContext
+                                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                        .emit("onPlaybackFinished", finishParams)
+                                }
+                            }
+
+                            override fun onIsPlayingChanged(isPlaying: Boolean) {
+                                val params = Arguments.createMap()
+                                params.putString("status", if (isPlaying) "PLAYING" else "PAUSED")
+                                reactContext
+                                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                    .emit("onPlaybackStatus", params)
+
+                                if (isPlaying) {
+                                    playbackHandler.post(playbackRunnable)
+                                } else {
+                                    playbackHandler.removeCallbacks(playbackRunnable)
+                                }
+                            }
+
+                            override fun onPlayerError(error: com.google.android.exoplayer2.ExoPlaybackException) {
+                                super.onPlayerError(error)
+                                val params = Arguments.createMap()
+                                params.putString("status", "ERROR")
+                                params.putString("message", error.localizedMessage)
+                                reactContext
+                                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                                    .emit("onPlaybackStatus", params)
+                            }
+                        },
+                    )
                 }
 
                 player?.apply {
@@ -239,22 +279,23 @@ class RecPlayModule(
                         clearMediaItems()
                     }
 
+                    val usage =
+                        when {
+                            duck -> com.google.android.exoplayer2.C.USAGE_ASSISTANCE_SONIFICATION
+                            mixWithOthers -> com.google.android.exoplayer2.C.USAGE_MEDIA
+                            else -> com.google.android.exoplayer2.C.USAGE_MEDIA
+                        }
+
                     val audioAttributes =
-                        com.google.android.exoplayer2.audio.AudioAttributes
+                        AudioAttributes
                             .Builder()
-                            .setUsage(com.google.android.exoplayer2.C.USAGE_MEDIA)
+                            .setUsage(usage)
                             .setContentType(com.google.android.exoplayer2.C.AUDIO_CONTENT_TYPE_MUSIC)
                             .build()
 
-                    setAudioAttributes(audioAttributes, true)
+                    setAudioAttributes(audioAttributes, !mixWithOthers)
 
-                    val mediaItem =
-                        MediaItem
-                            .Builder()
-                            .setUri(finalUri)
-                            // REQUIRED for remote .m4a from PHP
-                            .setMimeType("audio/mp4")
-                            .build()
+                    val mediaItem = MediaItem.fromUri(Uri.parse(uriString))
 
                     repeatMode =
                         if (loop) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
@@ -262,12 +303,17 @@ class RecPlayModule(
                     setMediaItem(mediaItem)
                     prepare()
                     playWhenReady = true
-
-                    playbackHandler.removeCallbacks(playbackRunnable)
-                    playbackHandler.post(playbackRunnable)
                 }
             } catch (e: Exception) {
                 Log.e(TAG, "Playback Error", e)
+
+                // ✅ Emit ERROR event to JS
+                val params = Arguments.createMap()
+                params.putString("status", "ERROR")
+                params.putString("message", e.localizedMessage)
+                reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("onPlaybackStatus", params)
             }
         }
     }

package/ios/RecPlayModule.swift

@@ -19,7 +19,10 @@ class RecPlayModule: RCTEventEmitter {
     }
 
     override func supportedEvents() -> [String]! {
-        return ["onTimerUpdate", "onPlaybackStatus", "onPlaybackProgress", "onPlaybackFinished", "onAudioInterruption"]
+        return [
+            "onTimerUpdate", "onPlaybackStatus", "onPlaybackProgress", "onPlaybackFinished",
+            "onAudioInterruption",
+        ]
     }
 
     override init() {
@@ -44,76 +47,76 @@ 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 {
-        // Build options dynamically based on new params
-        var options: AVAudioSession.CategoryOptions = [.defaultToSpeaker]
+    func startRecording(
+        fileName: String?,
+        shouldStopPlayback: Bool,
+        duck: Bool,
+        mixWithOthers: Bool,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
 
-        if duck {
-            options.insert(.duckOthers)
-        }
-        if mixWithOthers {
-            options.insert(.mixWithOthers)
+        if shouldStopPlayback {
+            stopPlaybackInternal()
         }
 
-        // Reset session if previously active
-        try? session.setActive(false)
-        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
-        ]
+        let session = AVAudioSession.sharedInstance()
 
-        audioRecorder = try AVAudioRecorder(url: fileURL, settings: settings)
-        audioRecorder?.prepareToRecord()
-        audioRecorder?.record()
+        do {
+            // Build options dynamically based on new params
+            var options: AVAudioSession.CategoryOptions = [.defaultToSpeaker]
 
-        secondsElapsed = 0
-        isPaused = false
+            if duck {
+                options.insert(.duckOthers)
+            }
+            if mixWithOthers {
+                options.insert(.mixWithOthers)
+            }
+
+            // Reset session if previously active
+            try? session.setActive(false)
+            try session.setCategory(.playAndRecord, mode: .default, options: options)
+            try session.setActive(true)
 
-        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
+            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
+                    }
                 }
             }
-        }
 
-        resolve(name)
+            resolve(name)
 
-    } catch {
-        reject("REC_ERROR", "Failed to start recording", error)
+        } catch {
+            reject("REC_ERROR", "Failed to start recording", error)
+        }
     }
-}
-
 
     @objc(stopRecording:rejecter:)
     func stopRecording(
@@ -130,7 +133,8 @@ func startRecording(
 
         // notify other audio that we deactivated so they can resume
         do {
-            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+            try AVAudioSession.sharedInstance().setActive(
+                false, options: .notifyOthersOnDeactivation)
         } catch {
             // non-fatal
             print("⚠️ setActive(false) failed: \(error.localizedDescription)")
@@ -196,69 +200,136 @@ func startRecording(
         uri: String,
         shouldStopPrevious: Bool,
         loop: Bool,
-       mixWithOthers: Bool,
+        mixWithOthers: Bool,
         duckOthers: Bool
-    ) {DispatchQueue.main.async { [weak self] in
-        guard let self = self else { return }
+    ) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
 
-        if shouldStopPrevious {
-            self.stopPlaybackInternal()
-        }
+            if shouldStopPrevious {
+                self.stopPlaybackInternal()
+            }
 
-        let session = AVAudioSession.sharedInstance()
+            let session = AVAudioSession.sharedInstance()
+            do {
+                try session.setActive(false)
 
-        do {
-            try session.setActive(false)
+                var options: AVAudioSession.CategoryOptions = []
 
-            var options: AVAudioSession.CategoryOptions = []
+                if mixWithOthers {
+                    options.insert(.mixWithOthers)
+                } else if duckOthers {
+                    options.insert(.duckOthers)
+                }
 
-            if mixWithOthers {
-                options.insert(.mixWithOthers)
-            } else if duckOthers {
-                options.insert(.duckOthers)
+                try session.setCategory(.playback, mode: .default, options: options)
+                try session.setActive(true)
+
+            } catch {
+                print("⚠️ Audio Session Error: \(error.localizedDescription)")
+                self.sendEvent(withName: "onPlaybackStatus", body: ["status": "ERROR"])
+                return
             }
 
-            try session.setCategory(.playback, mode: .default, options: options)
-            try session.setActive(true)
+            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
+            } else {
+                url = URL(fileURLWithPath: uri)
+            }
 
-        } catch {
-            print("⚠️ Audio Session Error: \(error.localizedDescription)")
-            return
-        }
+            let asset = AVURLAsset(url: url)
+            self.playerItem = AVPlayerItem(asset: asset)
+            self.isLooping = loop
 
-        let url: URL
-        if uri.hasPrefix("http") || uri.hasPrefix("file://") {
-            guard let u = URL(string: uri) else { return }
-            url = u
-        } else {
-            url = URL(fileURLWithPath: uri)
-        }
+            // Add observers for buffering & ready-to-play
+            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)
 
-        let asset = AVURLAsset(url: url)
-        self.playerItem = AVPlayerItem(asset: asset)
-        self.isLooping = loop
+            NotificationCenter.default.addObserver(
+                self,
+                selector: #selector(self.playerDidFinishPlaying),
+                name: .AVPlayerItemDidPlayToEndTime,
+                object: self.playerItem
+            )
 
-        self.playerItem?.addObserver(self, forKeyPath: "status", options: [.new], context: nil)
+            if self.audioPlayer == nil {
+                self.audioPlayer = AVPlayer(playerItem: self.playerItem)
+            } else {
+                self.audioPlayer?.replaceCurrentItem(with: self.playerItem)
+            }
 
-        NotificationCenter.default.addObserver(
-            self,
-            selector: #selector(self.playerDidFinishPlaying),
-            name: .AVPlayerItemDidPlayToEndTime,
-            object: self.playerItem
-        )
+            self.setupProgressObserver()
+            self.audioPlayer?.play()
 
-        if self.audioPlayer == nil {
-            self.audioPlayer = AVPlayer(playerItem: self.playerItem)
-        } else {
-            self.audioPlayer?.replaceCurrentItem(with: self.playerItem)
+            self.sendEvent(withName: "onPlaybackStatus", body: ["status": "PLAYING"])
         }
+    }
 
-        self.setupProgressObserver()
-        self.audioPlayer?.play()
+    // MARK: - Observers for Status / Buffering
+    override func observeValue(
+        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:
+                let isPlaying = self.audioPlayer?.timeControlStatus == .playing
+                self.sendEvent(
+                    withName: "onPlaybackStatus", body: ["status": isPlaying ? "PLAYING" : "PAUSED"]
+                )
+            case .failed:
+                self.sendEvent(withName: "onPlaybackStatus", body: ["status": "ERROR"])
+            default:
+                self.sendEvent(withName: "onPlaybackStatus", body: ["status": "IDLE"])
+            }
 
-        self.sendEvent(withName: "onPlaybackStatus", body: ["status": "PLAYING"])
-    }}
+        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
+        }
+    }
+
+    @objc func playerDidFinishPlaying(note: NSNotification) {
+        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"])
+            do {
+                try AVAudioSession.sharedInstance().setActive(
+                    false, options: .notifyOthersOnDeactivation)
+            } catch {
+                print("⚠️ setActive(false) failed: \(error.localizedDescription)")
+            }
+        }
+    }
 
     private func setupProgressObserver() {
 
@@ -283,7 +354,7 @@ func startRecording(
                 withName: "onPlaybackProgress",
                 body: [
                     "currentPosition": time.seconds,
-                    "duration": duration
+                    "duration": duration,
                 ]
             )
         }
@@ -294,7 +365,8 @@ func startRecording(
         stopPlaybackInternal()
         // notify others so they can resume
         do {
-            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+            try AVAudioSession.sharedInstance().setActive(
+                false, options: .notifyOthersOnDeactivation)
         } catch {
             print("⚠️ setActive(false) failed: \(error.localizedDescription)")
         }
@@ -338,46 +410,13 @@ func startRecording(
         }
     }
 
-    override func observeValue(
-        forKeyPath keyPath: String?,
-        of object: Any?,
-        change: [NSKeyValueChangeKey: Any]?,
-        context: UnsafeMutableRawPointer?
-    ) {
-
-        if keyPath == "status", let item = object as? AVPlayerItem {
-            if item.status == .failed {
-                sendEvent(withName: "onPlaybackStatus", body: ["status": "ERROR"])
-            } else if item.status == .readyToPlay {
-                // ready, but we don't force other players to resume here
-                print("DEBUG: Audio Ready")
-            }
-        }
-    }
-
-    @objc func playerDidFinishPlaying(note: NSNotification) {
-
-        if isLooping {
-            audioPlayer?.seek(to: .zero)
-            audioPlayer?.play()
-        } else {
-            sendEvent(withName: "onPlaybackFinished", body: ["finished": true])
-            sendEvent(withName: "onPlaybackStatus", body: ["status": "ENDED"])
-            // deactivate so others can resume
-            do {
-                try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-            } catch {
-                print("⚠️ setActive(false) failed: \(error.localizedDescription)")
-            }
-        }
-    }
-
     // MARK: - Interruption & Route Handling
 
     @objc private func handleAudioSessionInterruption(_ notification: Notification) {
         guard let info = notification.userInfo,
-              let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt,
-              let type = AVAudioSession.InterruptionType(rawValue: typeValue) else {
+            let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt,
+            let type = AVAudioSession.InterruptionType(rawValue: typeValue)
+        else {
             return
         }
 
@@ -389,15 +428,19 @@ func startRecording(
         case .ended:
             // interruption ended — optionally reactivate
             let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt
-            let shouldResume = (optionsValue ?? 0) & AVAudioSession.InterruptionOptions.shouldResume.rawValue != 0
-            sendEvent(withName: "onAudioInterruption", body: ["type": "ended", "shouldResume": shouldResume])
+            let shouldResume =
+                (optionsValue ?? 0) & AVAudioSession.InterruptionOptions.shouldResume.rawValue != 0
+            sendEvent(
+                withName: "onAudioInterruption",
+                body: ["type": "ended", "shouldResume": shouldResume])
             if shouldResume {
                 // try to reactivate and resume playback if appropriate
                 do {
                     try AVAudioSession.sharedInstance().setActive(true)
                     audioPlayer?.play()
                 } catch {
-                    print("⚠️ Failed to reactivate after interruption: \(error.localizedDescription)")
+                    print(
+                        "⚠️ Failed to reactivate after interruption: \(error.localizedDescription)")
                 }
             }
             print("🔊 Audio interruption ended. shouldResume: \(shouldResume)")
@@ -408,8 +451,9 @@ func startRecording(
 
     @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 }
+            let reasonValue = userInfo[AVAudioSessionRouteChangeReasonKey] as? UInt,
+            let reason = AVAudioSession.RouteChangeReason(rawValue: reasonValue)
+        else { return }
 
         switch reason {
         case .oldDeviceUnavailable:

package/package.json

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