rns-recplay 1.2.7

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

@@ -0,0 +1,291 @@
+package com.rnsrecplay
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.media.MediaRecorder
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.google.android.exoplayer2.ExoPlayer
+import com.google.android.exoplayer2.MediaItem
+import com.google.android.exoplayer2.Player // Add this import
+import java.io.File
+
+class RecPlayModule(
+    private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    // Add this line to fix the compilation error
+    private val TAG = "RecPlayDebug"
+
+    private var recorder: MediaRecorder? = null
+    private var player: ExoPlayer? = null
+    private var isPaused = false
+    private var secondsElapsed = 0
+    private val handler = Handler(Looper.getMainLooper())
+    private var playbackHandler = Handler(Looper.getMainLooper())
+    private var currentFilePath: String? = null
+
+    override fun getName(): String = "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)
+
+                        reactContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit("onPlaybackProgress", params)
+                    }
+                    playbackHandler.postDelayed(this, 500) // Update every 500ms
+                }
+            }
+        }
+
+    private val timerRunnable =
+        object : Runnable {
+            override fun run() {
+                if (recorder == null) return
+                if (!isPaused) {
+                    val params = Arguments.createMap()
+                    params.putInt("seconds", secondsElapsed)
+                    reactContext
+                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        .emit("onTimerUpdate", params)
+                    secondsElapsed++
+                }
+                handler.postDelayed(this, 1000)
+            }
+        }
+
+    // 1. Add this new explicit stop method
+    @ReactMethod
+    fun stopPlayback(promise: Promise?) {
+        handler.post {
+            try {
+                player?.let {
+                    if (it.isPlaying) {
+                        it.pause()
+                    }
+                    it.stop()
+                    it.clearMediaItems()
+                }
+                promise?.resolve(true)
+            } catch (e: Exception) {
+                promise?.reject("STOP_PLAY_ERROR", e.message)
+            }
+        }
+    }
+
+    // 2. Update startRecording to include playback cleanup
+    @ReactMethod
+    fun startRecording(
+        fileName: String?,
+        shouldStopPlayback: Boolean, // New parameter
+        promise: Promise,
+    ) {
+        handler.post {
+            try {
+                // 1. Conditional Playback Cleanup
+                if (shouldStopPlayback) {
+                    Log.d(TAG, "shouldStopPlayback is true: Stopping player...")
+                    player?.let {
+                        if (it.isPlaying) it.pause()
+                        it.stop()
+                        it.clearMediaItems()
+                    }
+                }
+
+                // 2. Standard Recorder Cleanup
+                Log.d(TAG, "Cleaning up old recorder...")
+                handler.removeCallbacks(timerRunnable)
+                recorder?.release()
+                recorder = null
+
+                // 3. File Setup
+                val name = fileName ?: "rec_${System.currentTimeMillis()}"
+                val file = File(reactContext.cacheDir, "$name.m4a")
+                if (file.exists()) file.delete()
+                currentFilePath = file.absolutePath
+
+                // 4. Recorder Initialization
+                val context = currentActivity ?: reactContext
+                recorder =
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        MediaRecorder(context)
+                    } else {
+                        @Suppress("DEPRECATION")
+                        MediaRecorder()
+                    }.apply {
+                        setAudioSource(MediaRecorder.AudioSource.MIC)
+                        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+                        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+                        setAudioEncodingBitRate(128000)
+                        setAudioSamplingRate(44100)
+                        setOutputFile(currentFilePath)
+                        prepare()
+                        start()
+                    }
+
+                secondsElapsed = 0
+                isPaused = false
+                handler.post(timerRunnable)
+                promise.resolve(name)
+            } catch (e: Exception) {
+                Log.e(TAG, "Start Error: ${e.message}")
+                recorder?.release()
+                recorder = null
+                promise.reject("REC_ERROR", e.message)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun stopRecording(promise: Promise) {
+        Log.d(TAG, "Stop requested")
+        handler.removeCallbacks(timerRunnable)
+        try {
+            recorder?.apply {
+                stop()
+                release()
+            }
+            recorder = null
+            isPaused = false
+            secondsElapsed = 0
+            promise.resolve("file://$currentFilePath")
+        } catch (e: Exception) {
+            Log.e(TAG, "Stop Error: ${e.message}")
+            recorder?.release()
+            recorder = null
+            promise.reject("STOP_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun pauseRecording(promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                recorder?.pause()
+                isPaused = true
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("PAUSE_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun resumeRecording(promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                recorder?.resume()
+                isPaused = false
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("RESUME_ERROR", e.message)
+        }
+    }
+
+    @ReactMethod
+    fun playAudio(
+        uriString: String,
+        shouldStopPrevious: Boolean,
+        loop: Boolean, // Added parameter
+    ) {
+        handler.post {
+            try {
+                if (player == null) {
+                    player = ExoPlayer.Builder(reactContext).build()
+                    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_READY && player?.isPlaying == true) {
+                                    playbackHandler.post(playbackRunnable)
+                                } else 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)
+                                }
+                            }
+                        },
+                    )
+                } else if (shouldStopPrevious) {
+                    playbackHandler.removeCallbacks(playbackRunnable)
+                    player?.stop()
+                    player?.clearMediaItems()
+                }
+
+                val mediaItem = MediaItem.fromUri(Uri.parse(uriString))
+                player?.apply {
+                    // This is the magic line for native looping
+                    repeatMode = if (loop) Player.REPEAT_MODE_ONE else Player.REPEAT_MODE_OFF
+
+                    setMediaItem(mediaItem)
+                    prepare()
+                    play()
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Playback Error: ${e.message}")
+            }
+        }
+    }
+
+    @ReactMethod
+    fun seekTo(seconds: Double) {
+        handler.post {
+            player?.seekTo((seconds * 1000).toLong())
+        }
+    }
+
+    @ReactMethod
+    fun togglePlayback() {
+        handler.post {
+            player?.let { if (it.isPlaying) it.pause() else it.play() }
+        }
+    }
+
+    override fun onCatalystInstanceDestroy() {
+        handler.removeCallbacks(timerRunnable)
+        recorder?.release()
+        player?.release()
+    }
+}

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

@@ -0,0 +1,15 @@
+package com.rnsrecplay
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import java.util.Collections
+
+class RecPlayPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> = listOf(RecPlayModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList() // We don't have any UI components, just logic
+    }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./withNativeRecPlay');

package/index.d.ts

@@ -0,0 +1,34 @@
+export type PlaybackStatus = "BUFFERING" | "PLAYING" | "PAUSED" | "ENDED" | "IDLE";
+
+declare const Recplay: {
+    startRecording: (
+        fileName?: string | null,
+        shouldStopPlayback?: boolean,
+        onSecondsUpdate?: (seconds: number) => void
+    ) => Promise<string>;
+
+    stopRecording: () => Promise<string>;
+    pauseRecording: () => Promise<boolean>;
+    resumeRecording: () => Promise<boolean>;
+    seekTo: (seconds: number) => void;
+
+    /**
+     * Plays audio with optional status and progress tracking.
+     * Order: uri, shouldStopPrevious, callbacks
+     */
+    playAudio: (
+        uri: string,
+        shouldStopPrevious?: boolean,
+        loop?: boolean,
+        callbacks?: {
+            onPlaybackFinished?: () => void;
+            onStatus?: (status: PlaybackStatus) => void;
+            onProgress?: (currentPosition: number, duration: number) => void;
+        }
+    ) => void;
+
+    stopPlayback: () => Promise<boolean>;
+    togglePlayback: () => void;
+};
+
+export default Recplay;

package/index.js

@@ -0,0 +1,67 @@
+import { NativeModules, NativeEventEmitter } from 'react-native';
+
+const { RecPlayModule } = NativeModules;
+const eventEmitter = new NativeEventEmitter(RecPlayModule);
+
+let internalSub = null;
+let internalPlaySub = null;
+let internalStatusSub = null;
+let internalProgressSub = null;
+
+const Recplay = {
+    startRecording: async (fileName = null, shouldStopPlayback = true, onSecondsUpdate = null) => {
+        if (internalSub) internalSub.remove();
+        if (onSecondsUpdate) {
+            internalSub = eventEmitter.addListener('onTimerUpdate', (data) => onSecondsUpdate(data.seconds));
+        }
+        return RecPlayModule.startRecording(fileName, shouldStopPlayback);
+    },
+
+    stopRecording: async () => {
+        if (internalSub) { internalSub.remove(); internalSub = null; }
+        return RecPlayModule.stopRecording();
+    },
+
+    /**
+      * @param {string} uri 
+      * @param {boolean} shouldStopPrevious 
+      * @param {boolean} loop - New native loop flag
+      * @param {object} callbacks 
+      */
+    playAudio: (uri, shouldStopPrevious = false, loop = false, callbacks = {}) => {
+        // Cleanup listeners
+        [internalPlaySub, internalStatusSub, internalProgressSub].forEach(s => s?.remove());
+
+        if (callbacks.onFinished) {
+            internalPlaySub = eventEmitter.addListener('onPlaybackFinished', () => {
+                callbacks.onFinished();
+                internalPlaySub?.remove();
+            });
+        }
+
+        if (callbacks.onStatus) {
+            internalStatusSub = eventEmitter.addListener('onPlaybackStatus', (data) => callbacks.onStatus(data.status));
+        }
+
+        if (callbacks.onProgress) {
+            internalProgressSub = eventEmitter.addListener('onPlaybackProgress', (data) =>
+                callbacks.onProgress(data.currentPosition, data.duration)
+            );
+        }
+
+        // Pass all three arguments to Native
+        RecPlayModule.playAudio(uri, shouldStopPrevious, loop);
+    },
+
+    stopPlayback: () => {
+        [internalPlaySub, internalStatusSub, internalProgressSub].forEach(s => s?.remove());
+        return RecPlayModule.stopPlayback();
+    },
+
+    seekTo: (seconds) => RecPlayModule.seekTo(seconds),
+    pauseRecording: () => RecPlayModule.pauseRecording(),
+    resumeRecording: () => RecPlayModule.resumeRecording(),
+    togglePlayback: () => RecPlayModule.togglePlayback()
+};
+
+export default Recplay;

package/ios/RecPlayModule.m

@@ -0,0 +1,29 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE (RecPlayModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(startRecording : (NSString *)fileName shouldStopPlayback : (
+    BOOL)shouldStopPlayback resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopRecording : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(pauseRecording : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(resumeRecording : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(playAudio : (NSString *)uri shouldStopPrevious : (BOOL)
+                      shouldStopPrevious loop : (BOOL)loop)
+
+RCT_EXTERN_METHOD(stopPlayback : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(seekTo : (double)seconds)
+
+RCT_EXTERN_METHOD(togglePlayback)
+
+@end

package/ios/RecPlayModule.swift

@@ -0,0 +1,177 @@
+import Foundation
+import AVFoundation
+import React
+
+@objc(RecPlayModule)
+class RecPlayModule: RCTEventEmitter {
+    
+    private var audioRecorder: AVAudioRecorder?
+    private var audioPlayer: AVPlayer?
+    private var playerItemContext = 0
+    private var timeObserverToken: Any?
+    
+    private var recordingTimer: Timer?
+    private var secondsElapsed = 0
+    private var isPaused = false
+    private var isLooping = false
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    override func supportedEvents() -> [String]! {
+        return ["onTimerUpdate", "onPlaybackStatus", "onPlaybackProgress", "onPlaybackFinished"]
+    }
+
+    // MARK: - Recording Logic
+    
+    @objc(startRecording:shouldStopPlayback:resolver:rejecter:)
+    func startRecording(fileName: String?, shouldStopPlayback: Bool, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        
+        if shouldStopPlayback {
+            stopPlaybackInternal()
+        }
+        
+        let session = AVAudioSession.sharedInstance()
+        do {
+            // Set category for both recording and playback
+            try session.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker, .allowBluetooth])
+            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()
+            
+            self.secondsElapsed = 0
+            self.isPaused = false
+            
+            DispatchQueue.main.async {
+                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)
+        } catch {
+            reject("REC_ERROR", "Failed to start recording", error)
+        }
+    }
+
+    @objc(stopRecording:rejecter:)
+    func stopRecording(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        recordingTimer?.invalidate()
+        recordingTimer = nil
+        
+        audioRecorder?.stop()
+        let url = audioRecorder?.url
+        audioRecorder = nil
+        
+        if let fileUrl = url {
+            resolve(fileUrl.absoluteString)
+        } else {
+            reject("STOP_ERROR", "No recording found", nil)
+        }
+    }
+
+    @objc(pauseRecording:rejecter:)
+    func pauseRecording(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        audioRecorder?.pause()
+        isPaused = true
+        resolve(true)
+    }
+
+    @objc(resumeRecording:rejecter:)
+    func resumeRecording(resolve: RCTPromiseResolveBlock, reject: RCTPromiseRejectBlock) {
+        audioRecorder?.record()
+        isPaused = false
+        resolve(true)
+    }
+
+    // MARK: - Playback Logic
+
+    @objc(playAudio:shouldStopPrevious:loop:)
+    func playAudio(uri: String, shouldStopPrevious: Bool, loop: Bool) {
+        if shouldStopPrevious {
+            stopPlaybackInternal()
+        }
+        
+        guard let url = URL(string: uri) else { return }
+        self.isLooping = loop
+        
+        let playerItem = AVPlayerItem(url: url)
+        audioPlayer = AVPlayer(playerItem: playerItem)
+        
+        // Add Observer for Progress
+        let interval = CMTime(seconds: 0.5, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
+        timeObserverToken = audioPlayer?.addPeriodicTimeObserver(forInterval: interval, queue: .main) { [weak self] time in
+            guard let self = self, let duration = self.audioPlayer?.currentItem?.duration.seconds, duration > 0 else { return }
+            self.sendEvent(withName: "onPlaybackProgress", body: [
+                "currentPosition": time.seconds,
+                "duration": duration
+            ])
+        }
+        
+        // Notification for Finished
+        NotificationCenter.default.addObserver(self, selector: #selector(playerDidFinishPlaying), name: .AVPlayerItemDidPlayToEndTime, object: playerItem)
+        
+        audioPlayer?.play()
+        sendEvent(withName: "onPlaybackStatus", body: ["status": "PLAYING"])
+    }
+
+    @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"])
+        }
+    }
+
+    @objc(stopPlayback:rejecter:)
+    func stopPlayback(resolve: RCTPromiseResolveBlock?, reject: RCTPromiseRejectBlock?) {
+        stopPlaybackInternal()
+        resolve?(true)
+    }
+
+    private func stopPlaybackInternal() {
+        if let token = timeObserverToken {
+            audioPlayer?.removeTimeObserver(token)
+            timeObserverToken = nil
+        }
+        audioPlayer?.pause()
+        audioPlayer = nil
+        NotificationCenter.default.removeObserver(self, name: .AVPlayerItemDidPlayToEndTime, object: nil)
+    }
+
+    @objc(seekTo:)
+    func seekTo(seconds: Double) {
+        let time = CMTime(seconds: seconds, preferredTimescale: 1000)
+        audioPlayer?.seek(to: time)
+    }
+
+    @objc(togglePlayback)
+    func togglePlayback() {
+        if audioPlayer?.timeControlStatus == .playing {
+            audioPlayer?.pause()
+            sendEvent(withName: "onPlaybackStatus", body: ["status": "PAUSED"])
+        } else {
+            audioPlayer?.play()
+            sendEvent(withName: "onPlaybackStatus", body: ["status": "PLAYING"])
+        }
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "rns-recplay",
+    "version": "1.2.7",
+    "description": "High-performance React Native module for audio recording and audio playback on Android and iOS.",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "expo": {
+        "autolinking": {
+            "ios": {
+                "podspec": "rns-recplay.podspec"
+            }
+        },
+        "plugin": "./app.plugin.js"
+    },
+    "homepage": "https://github.com/raiidr/rns-recplay",
+    "license": "MIT",
+    "author": "Raiidr <info@raiidr.com>",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/raiidr/rns-recplay.git"
+    },
+    "scripts": {
+        "p": "npm publish --access public"
+    },
+    "keywords": [
+        "react-native",
+        "recplay",
+        "recoridng",
+        "audio",
+        "android",
+        "ios",
+        "expo",
+        "config-plugin"
+    ],
+    "files": [
+        "android",
+        "ios",
+        "app.plugin.js",
+        "index.d.ts",
+        "index.js",
+        "react-native.config.js",
+        "rns-recplay.podspec",
+        "withrecplayVoip.js"
+    ],
+    "peerDependencies": {
+        "expo": ">=45.0.0",
+        "react-native": ">=0.60.0"
+    },
+    "dependencies": {
+        "@expo/config-plugins": "^9.0.0"
+    }
+}

package/react-native.config.js

@@ -0,0 +1,12 @@
+///Users/bush/Desktop/Apps/Raiidr/package/react-native.config.js
+module.exports = {
+    dependencies: {
+        'rns-nativecall': {
+            platforms: {
+                ios: {
+                    podspecPath: 'rns-nativecall.podspec',
+                },
+            },
+        },
+    },
+};