rns-recplay 2.0.3 → 3.0.0

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

@@ -14,12 +14,10 @@ import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
-import android.view.KeyEvent
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.*
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.modules.core.PermissionAwareActivity
-import com.facebook.react.modules.core.PermissionListener
 import com.google.android.exoplayer2.C
 import com.google.android.exoplayer2.ExoPlayer
 import com.google.android.exoplayer2.MediaItem
@@ -27,6 +25,7 @@ import com.google.android.exoplayer2.Player
 import com.google.android.exoplayer2.audio.AudioAttributes
 import java.io.File
 import android.media.AudioAttributes as AndroidAudioAttributes
+import kotlin.math.log10
 
 class RecPlayModule(
     private val reactContext: ReactApplicationContext,
@@ -35,8 +34,12 @@ class RecPlayModule(
 
     private var recorder: MediaRecorder? = null
     private var player: ExoPlayer? = null
+
     private var isPaused = false
-    private var secondsElapsed = 0
+    private var secondsElapsed = 0.0
+    private var subSecondTicks = 0 
+    private var recordingStartMs = 0L
+    private var accumulatedRecordingMs = 0L
 
     private var audioFocusRequest: AudioFocusRequest? = null
     private var audioFocusChangeListener: AudioManager.OnAudioFocusChangeListener? = null
@@ -51,6 +54,42 @@ class RecPlayModule(
 
     override fun getName(): String = "RecPlayModule"
 
+    private fun getRecordingDurationSeconds(): Double {
+        val activeSegmentMs = if (!isPaused && recordingStartMs > 0L) {
+            System.currentTimeMillis() - recordingStartMs
+        } else {
+            0L
+        }
+        return (accumulatedRecordingMs + activeSegmentMs) / 1000.0
+    }
+
+    private fun resolveRecorderAudioSource(useBT: Boolean): Int =
+        when {
+            useBT && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> MediaRecorder.AudioSource.VOICE_COMMUNICATION
+            isCommunicationActive() -> MediaRecorder.AudioSource.VOICE_COMMUNICATION
+            else -> MediaRecorder.AudioSource.MIC
+        }
+
+
+    private fun stopPlaybackInternal() {
+        playbackHandler.removeCallbacks(playbackRunnable)
+        player?.stop()
+        player?.release()
+        player = null
+        abandonAudioFocus()
+        unregisterNoisyReceiver()
+    }
+
+    private fun resolvePlaybackUri(uriString: String): Uri {
+        val trimmed = uriString.trim()
+        return if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+            Uri.parse(trimmed)
+        } else {
+            val literalPath = trimmed.removePrefix("file://")
+            Uri.fromFile(File(literalPath))
+        }
+    }
+
     // --- NEW: WebRTC Detection Helper ---
     private fun isCommunicationActive(): Boolean {
         val audioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
@@ -164,40 +203,74 @@ class RecPlayModule(
     }
 
     private val playbackRunnable =
-        object : Runnable {
-            override fun run() {
-                player?.let {
-                    if (it.isPlaying) {
-                        val params = Arguments.createMap()
-                        params.putDouble("currentPosition", it.currentPosition.toDouble() / 1000.0)
-                        params.putDouble("duration", it.duration.toDouble() / 1000.0)
-                        sendEvent("onPlaybackProgress", params)
-                    }
-                    playbackHandler.postDelayed(this, 500)
+    object : Runnable {
+        override fun run() {
+            val currentPlayer = player ?: run {
+                // No player — stop rescheduling, mirrors iOS progress observer guard
+                playbackHandler.removeCallbacks(this)
+                return
+            }
+            if (currentPlayer.isPlaying) {
+                val rawDuration = currentPlayer.duration
+                if (rawDuration != C.TIME_UNSET && rawDuration >= 0) {
+                    val params = Arguments.createMap()
+                    params.putDouble("currentPosition", currentPlayer.currentPosition.toDouble() / 1000.0)
+                    params.putDouble("duration", rawDuration.toDouble() / 1000.0)
+                    sendEvent("onPlaybackProgress", params)
                 }
             }
+            playbackHandler.postDelayed(this, 50)
         }
+    }
 
     private val timerRunnable =
-        object : Runnable {
+    object : Runnable {
             override fun run() {
-                if (recorder == null) return
+                val currentRecorder = recorder ?: run {
+                     // Mirror iOS: invalidate self when recorder is gone, don't reschedule
+                    handler.removeCallbacks(this)
+                    return
+                }
                 if (!isPaused) {
-                    val params = Arguments.createMap()
-                    params.putInt("seconds", secondsElapsed)
-                    sendEvent("onTimerUpdate", params)
-                    secondsElapsed++
+                    // 1. Volume Logic
+                    val maxAmp = currentRecorder.maxAmplitude
+                    val db = if (maxAmp > 0) 20 * log10(maxAmp.toDouble() / 32767.0) else -160.0
+                    val normalizedVolume = ((db + 60) / 60).coerceIn(0.0, 1.0)
+
+                    sendEvent("onVolumeUpdate", Arguments.createMap().apply {
+                        putDouble("value", db)
+                        putDouble("normalized", normalizedVolume)
+                    })
+
+                    // 2. Timer Logic (Executes every 10 ticks = 1 second)
+                    subSecondTicks++
+                    if (subSecondTicks >= 10) {
+                        secondsElapsed = getRecordingDurationSeconds()
+                        sendEvent("onTimerUpdate", Arguments.createMap().apply {
+                            putInt("seconds", secondsElapsed.toInt())
+                        })
+                        subSecondTicks = 0
+                    }
                 }
-                handler.postDelayed(this, 1000)
+                handler.postDelayed(this, 100) // Change 1000 to 100
             }
-        }
+    }
+
+    private fun stopTimer() {
+        handler.removeCallbacks(timerRunnable)
+        subSecondTicks = 0
+    }
 
     private fun sendEvent(
         eventName: String,
         params: WritableMap?,
     ) {
-        if (reactContext.hasActiveCatalystInstance()) {
-            reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java).emit(eventName, params)
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(eventName, params)
+        } catch (e: Exception) {
+            Log.w(TAG, "sendEvent '$eventName' dropped — JS not ready: ${e.message}")
         }
     }
 
@@ -212,10 +285,7 @@ class RecPlayModule(
         handler.post {
             try {
                 if (shouldStopPrevious || player != null) {
-                    playbackHandler.removeCallbacks(playbackRunnable)
-                    player?.stop()
-                    player?.release()
-                    player = null
+                    stopPlaybackInternal()
                 }
 
                 // If call is active, force ducking instead of exclusive focus
@@ -234,26 +304,52 @@ class RecPlayModule(
                         addListener(
                             object : Player.Listener {
                                 override fun onPlaybackStateChanged(state: Int) {
-                                    if (state == Player.STATE_ENDED) {
-                                        playbackHandler.removeCallbacks(playbackRunnable)
-                                        abandonAudioFocus()
-                                        unregisterNoisyReceiver()
-                                        sendEvent("onPlaybackFinished", Arguments.createMap().apply { putBoolean("finished", true) })
+                                    when (state) {
+                                        Player.STATE_BUFFERING -> {
+                                            sendEvent("onPlaybackStatus", Arguments.createMap().apply { putString("status", "BUFFERING") })
+                                        }
+                                        Player.STATE_READY -> {
+                                            if (playWhenReady) {
+                                                sendEvent("onPlaybackStatus", Arguments.createMap().apply { putString("status", "PLAYING") })
+                                            } else {
+                                                sendEvent("onPlaybackStatus", Arguments.createMap().apply { putString("status", "PAUSED") })
+                                            }
+                                        }
+                                        Player.STATE_ENDED -> {
+                                            playbackHandler.removeCallbacks(playbackRunnable)
+                                            abandonAudioFocus()
+                                            unregisterNoisyReceiver()
+                                            sendEvent("onPlaybackFinished", Arguments.createMap().apply { putBoolean("finished", true) })
+                                            sendEvent("onPlaybackStatus", Arguments.createMap().apply { putString("status", "ENDED") })
+                                        }
                                     }
                                 }
 
                                 override fun onIsPlayingChanged(isPlaying: Boolean) {
-                                    sendEvent(
-                                        "onPlaybackStatus",
-                                        Arguments.createMap().apply { putString("status", if (isPlaying) "PLAYING" else "PAUSED") },
-                                    )
+                                    if (!isPlaying && player?.playbackState == Player.STATE_READY) {
+                                        // Only send PAUSED when the player is ready but not playing (user-driven pause).
+                                        // Do NOT send here during STATE_BUFFERING — that's onPlaybackStateChanged's job.
+                                        sendEvent("onPlaybackStatus", Arguments.createMap().apply { putString("status", "PAUSED") })
+                                    }
                                     if (isPlaying) {
                                         playbackHandler.post(playbackRunnable)
                                         registerNoisyReceiver()
                                     } else {
+                                        playbackHandler.removeCallbacks(playbackRunnable)
                                         unregisterNoisyReceiver()
                                     }
                                 }
+
+                                override fun onPlayerError(error: com.google.android.exoplayer2.PlaybackException) {
+                                    Log.e(TAG, "playAudio failed for $uriString", error)
+                                    playbackHandler.removeCallbacks(playbackRunnable)
+                                    abandonAudioFocus()
+                                    unregisterNoisyReceiver()
+                                    sendEvent("onPlaybackStatus", Arguments.createMap().apply {
+                                        putString("status", "ERROR")
+                                        putString("message", error.message ?: "Playback failed")
+                                    })
+                                }
                             },
                         )
                     }
@@ -266,11 +362,14 @@ class RecPlayModule(
                         .build()
                 player?.setAudioAttributes(audioAttributes, false)
 
-                player?.setMediaItem(MediaItem.fromUri(Uri.parse(uriString)))
+                val resolvedUri = resolvePlaybackUri(uriString)
+                Log.d(TAG, "playAudio resolved uri=$resolvedUri from input=$uriString")
+                player?.setMediaItem(MediaItem.fromUri(resolvedUri))
                 player?.prepare()
                 player?.repeatMode = if (loop) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
                 player?.playWhenReady = true
             } catch (e: Exception) {
+                Log.e(TAG, "playAudio exception for $uriString", e)
                 sendEvent("onPlaybackStatus", Arguments.createMap().apply { putString("status", "ERROR") })
             }
         }
@@ -282,11 +381,12 @@ class RecPlayModule(
         shouldStopPlayback: Boolean,
         duck: Boolean,
         mixWithOthers: Boolean,
+        useBT: Boolean,
         promise: Promise,
     ) {
         handler.post {
             try {
-                if (shouldStopPlayback) stopPlayback(null)
+                if (shouldStopPlayback) stopPlaybackInternal()
 
                 val focusType: Int? =
                     when {
@@ -304,9 +404,7 @@ class RecPlayModule(
 
                 recorder =
                     (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) MediaRecorder(reactContext) else MediaRecorder()).apply {
-                        // Use VOICE_COMMUNICATION if in a call to share mic with WebRTC
-                        val source = if (isCommunicationActive()) MediaRecorder.AudioSource.VOICE_COMMUNICATION else MediaRecorder.AudioSource.MIC
-                        setAudioSource(source)
+                        setAudioSource(resolveRecorderAudioSource(useBT))
                         setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
                         setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
                         setAudioEncodingBitRate(128000)
@@ -316,9 +414,14 @@ class RecPlayModule(
                         start()
                     }
 
-                secondsElapsed = 0
+                secondsElapsed = 0.0
+                accumulatedRecordingMs = 0L
+                recordingStartMs = System.currentTimeMillis()
+                subSecondTicks = 0 // Reset sub-ticks
                 isPaused = false
+                handler.removeCallbacks(timerRunnable)
                 handler.post(timerRunnable)
+
                 promise.resolve(name)
             } catch (e: Exception) {
                 recorder?.release()
@@ -330,36 +433,54 @@ class RecPlayModule(
 
     @ReactMethod
     fun stopRecording(promise: Promise) {
-        handler.removeCallbacks(timerRunnable)
-        try {
-            recorder?.stop()
-            recorder?.release()
-            recorder = null
-            abandonAudioFocus()
-            promise.resolve("file://$currentFilePath")
-        } catch (e: Exception) {
-            promise.reject("STOP_ERROR", e.message)
+        handler.post {
+            try {
+                val finalDuration = getRecordingDurationSeconds()
+                recorder?.apply {
+                    stop()
+                    release()
+                }
+    
+                val uri = "file://$currentFilePath"
+    
+                val result = Arguments.createMap().apply {
+                    putString("uri", uri)
+                    putDouble("duration", finalDuration)
+                }
+    
+                recorder = null
+                currentFilePath = null  // ← mirrors iOS clearing audioRecorder which drops the URL
+                secondsElapsed = finalDuration
+                accumulatedRecordingMs = 0L
+                recordingStartMs = 0L
+                isPaused = false
+                stopTimer()
+                abandonAudioFocus()
+                promise.resolve(result)
+            } catch (e: Exception) {
+                promise.reject("STOP_ERROR", e.message)
+            }
         }
     }
 
     @ReactMethod
     fun stopPlayback(promise: Promise?) {
         handler.post {
-            playbackHandler.removeCallbacks(playbackRunnable)
-            player?.stop()
-            player?.release()
-            player = null
-            abandonAudioFocus()
-            unregisterNoisyReceiver()
+            stopPlaybackInternal()
             promise?.resolve(true)
         }
     }
 
-    @ReactMethod
-    fun pauseRecording(promise: Promise) {
+@ReactMethod
+fun pauseRecording(promise: Promise) {
+    handler.post {
         try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                 recorder?.pause()
+                if (!isPaused && recordingStartMs > 0L) {
+                    accumulatedRecordingMs += System.currentTimeMillis() - recordingStartMs
+                    recordingStartMs = 0L
+                }
                 isPaused = true
             }
             promise.resolve(true)
@@ -367,12 +488,17 @@ class RecPlayModule(
             promise.reject("PAUSE_ERROR", e.message)
         }
     }
+}
 
-    @ReactMethod
-    fun resumeRecording(promise: Promise) {
+@ReactMethod
+fun resumeRecording(promise: Promise) {
+    handler.post {
         try {
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                 recorder?.resume()
+                if (isPaused) {
+                    recordingStartMs = System.currentTimeMillis()
+                }
                 isPaused = false
             }
             promise.resolve(true)
@@ -380,16 +506,48 @@ class RecPlayModule(
             promise.reject("RESUME_ERROR", e.message)
         }
     }
+}
+
+    @ReactMethod
+    fun seekTo(seconds: Double) {
+        handler.post {
+            player?.seekTo((seconds * 1000).toLong().coerceAtLeast(0L))
+        }
+    }
+
+    @ReactMethod
+    fun togglePlayback() {
+        handler.post {
+            player?.let {
+                if (it.isPlaying) {
+                    it.pause()
+                } else {
+                    it.play()
+                }
+            }
+        }
+    }
 
     @ReactMethod
     fun checkPermission(promise: Promise) {
-        val granted = ContextCompat.checkSelfPermission(reactContext, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
-        promise.resolve(if (granted) "granted" else "denied")
+        val isGranted = ContextCompat.checkSelfPermission(reactContext, Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
+        if (isGranted) {
+            promise.resolve("granted")
+            return
+        }
+        // shouldShowRequestPermissionRationale returns false AFTER a denial with "Don't ask again"
+        // — that's the Android equivalent of iOS's "blocked" state
+        val activity = reactApplicationContext.currentActivity
+        val isBlocked = activity != null &&
+            !androidx.core.app.ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.RECORD_AUDIO)
+        promise.resolve(if (isBlocked) "blocked" else "denied")
     }
 
     @ReactMethod
     fun requestPermission(promise: Promise) {
-        val activity = currentActivity as? PermissionAwareActivity ?: return promise.reject("ERROR", "No Activity")
+        val activity =
+            reactApplicationContext.currentActivity as? PermissionAwareActivity
+                ?: return promise.reject("ERROR", "No Activity")
         activity.requestPermissions(arrayOf(Manifest.permission.RECORD_AUDIO), 101) { requestCode, _, grantResults ->
             if (requestCode ==
                 101
@@ -408,6 +566,12 @@ class RecPlayModule(
         }
     }
 
+    @ReactMethod
+    fun addListener(eventName: String) { /* required by NativeEventEmitter */ }
+
+    @ReactMethod
+    fun removeListeners(count: Int) { /* required by NativeEventEmitter */ }
+
     override fun onCatalystInstanceDestroy() {
         handler.removeCallbacks(timerRunnable)
         playbackHandler.removeCallbacks(playbackRunnable)

package/index.d.ts

@@ -1,6 +1,9 @@
 export type PermissionStatus = "granted" | "denied" | "blocked" | "unavailable";
 export type PlaybackStatus = "BUFFERING" | "PLAYING" | "PAUSED" | "ENDED" | "IDLE";
-
+export type RecordingResult = {
+    uri: string;
+    duration: number; // Duration in seconds (e.g., 5.4)
+};
 /**
  * Options for playback audio
  */
@@ -38,8 +41,15 @@ export type RecordingOptions = {
     duck?: boolean;
     /** Mix recording with other apps? Default: true */
     mixWithOthers?: boolean;
+    /** useBT recording via bluetooth mic or not. Default: false */
+    useBT?: boolean;
     /** Callback fired every second with elapsed seconds */
     onSecondsUpdate?: (seconds: number) => void;
+    /** * Callback fired every 100ms with volume data 
+     * @param db Raw decibel value (approx. -60 to 0)
+     * @param normalized Normalized value (0.0 to 1.0) for UI bars
+     */
+    onVolumeUpdate?: (db: number, normalized: number) => void;
 };
 
 /**
@@ -51,11 +61,9 @@ declare const Recplay: {
      * Start recording audio
      * @example
      * const fileName = await Recplay.startRecording({
-     *   fileName: "myrec",
-     *   shouldStopPlayback: true,
-     *   duck: false,
-     *   mixWithOthers: false,
-     *   onSecondsUpdate: (s) => console.log("Recording seconds:", s)
+     * fileName: "myrec",
+     * onSecondsUpdate: (s) => console.log("Seconds:", s),
+     * onVolumeUpdate: (db, vol) => console.log("Volume:", vol) // 0.0 - 1.0
      * });
      */
     startRecording: (options?: RecordingOptions) => Promise<string>;
@@ -66,7 +74,7 @@ declare const Recplay: {
      * const recordedFile = await Recplay.stopRecording();
      * console.log("Recorded file path:", recordedFile);
      */
-    stopRecording: () => Promise<string>;
+    stopRecording: () => Promise<RecordingResult>;
 
     /**
      * Pause current recording
@@ -93,7 +101,6 @@ declare const Recplay: {
      * Check microphone permission
      * @example
      * const status = await Recplay.checkPermission();
-     * console.log(status); // "granted" | "denied" | "blocked" | "unavailable"
      */
     checkPermission: () => Promise<PermissionStatus>;
 
@@ -101,39 +108,21 @@ declare const Recplay: {
      * Request microphone permission
      * @example
      * const status = await Recplay.requestPermission();
-     * console.log(status); // "granted" | "denied" | "blocked" | "unavailable"
      */
     requestPermission: () => Promise<PermissionStatus>;
 
     /**
      * Play audio with options object
-     * @example
-     * Recplay.playAudio({
-     *   uri: "file.mp3",
-     *   shouldStopPrevious: true,
-     *   loop: false,
-     *   mixWithOthers: false,
-     *   duck: true,
-     *   callbacks: {
-     *     onStatus: (s) => console.log("Status:", s),
-     *     onProgress: (cur, dur) => console.log("Progress:", cur, "/", dur),
-     *     onPlaybackFinished: () => console.log("Playback finished")
-     *   }
-     * });
      */
     playAudio: (options: PlaybackOptions) => void;
 
     /**
     * Stop current playback
-    * @example
-    * await Recplay.stopPlayback();
     */
     stopPlayback: () => Promise<boolean>;
 
     /**
      * Toggle playback pause/resume
-     * @example
-     * Recplay.togglePlayback();
      */
     togglePlayback: () => void;
 };

package/index.js

@@ -4,6 +4,7 @@ const { RecPlayModule } = NativeModules;
 const eventEmitter = new NativeEventEmitter(RecPlayModule);
 
 let internalSub = null;
+let internalVolumeSub = null; // New: listener for 100ms volume updates
 let internalPlaySub = null;
 let internalStatusSub = null;
 let internalProgressSub = null;
@@ -16,22 +17,42 @@ const Recplay = {
         shouldStopPlayback = true,
         duck = true,
         mixWithOthers = true,
+        useBT = false,
         onSecondsUpdate = null,
+        onVolumeUpdate = null, // New callback for UI visualizers
     } = {}) => {
-        if (internalSub) internalSub.remove();
+        // Clean up any existing recording subscriptions
+        [internalSub, internalVolumeSub].forEach(s => s?.remove());
+
         if (onSecondsUpdate) {
             internalSub = eventEmitter.addListener('onTimerUpdate', (data) => {
                 onSecondsUpdate(data.seconds);
             });
         }
-        return RecPlayModule.startRecording(fileName, shouldStopPlayback, duck, mixWithOthers);
+
+        if (onVolumeUpdate) {
+            internalVolumeSub = eventEmitter.addListener('onVolumeUpdate', (data) => {
+                // data contains { value: dB, normalized: 0.0-1.0 }
+                onVolumeUpdate(data.value, data.normalized);
+            });
+        }
+
+        return RecPlayModule.startRecording(fileName, shouldStopPlayback, duck, mixWithOthers, useBT);
     },
 
 
     /** Stop recording */
     stopRecording: async () => {
-        if (internalSub) { internalSub.remove(); internalSub = null; }
-        return RecPlayModule.stopRecording();
+        // 1. Cleanup JS listeners
+        [internalSub, internalVolumeSub].forEach(s => s?.remove());
+        internalSub = null;
+        internalVolumeSub = null;
+
+        // 2. Get the object { uri, duration } from Native
+        const result = await RecPlayModule.stopRecording();
+
+        // Result is now { uri: string, duration: number }
+        return result;
     },
 
     /** Pause recording */
@@ -70,7 +91,6 @@ const Recplay = {
             );
         }
 
-        // Map named params to native positional params
         RecPlayModule.playAudio(uri, shouldStopPrevious, loop, mixWithOthers, duck);
     },
 
@@ -84,4 +104,4 @@ const Recplay = {
     togglePlayback: () => RecPlayModule.togglePlayback(),
 };
 
-export default Recplay;
+export default Recplay;

package/ios/RecPlayModule.m

@@ -24,6 +24,7 @@ RCT_EXTERN_METHOD(startRecording
                   : (BOOL)duck
                   mixWithOthers
                   : (BOOL)mixWithOthers
+                  useBT:(BOOL)useBT
                   resolver
                   : (RCTPromiseResolveBlock)resolve
                   rejecter