nosnia-audio-recorder 0.1.1 → 0.3.0

package/README.md

@@ -8,6 +8,8 @@ A compact, high-performance audio recorder library for React Native that records
 - 📱 **Cross-Platform**: Works seamlessly on iOS and Android
 - 🎚️ **Configurable**: Adjust bitrate, sample rate, and channels
 - ⏸️ **Pause/Resume**: Full control over recording with pause and resume
+- ⏱️ **Real-time Duration**: Get continuous recording duration updates via callback
+- ▶️ **MP3 Playback**: Built-in audio player with play/pause/resume/stop/seek
 - 🔒 **Permission Handling**: Built-in permission checking and requesting
 - 💾 **File Management**: Automatic file naming and directory management
 - 📦 **Compact**: Minimal dependencies, optimized for bundle size
@@ -48,10 +50,11 @@ const filePath = await NosniaAudioRecorder.stopRecording();
 console.log('Recording saved to:', filePath);
 ```
 
-### Full Example
+### Full Example (Record + Playback)
 
 ```js
-import { NosniaAudioRecorder } from 'nosnia-audio-recorder';
+import { NosniaAudioRecorder, NosniaAudioPlayer } from 'nosnia-audio-recorder';
+import { useState } from 'react';
 
 // Check and request permission
 const hasPermission = await NosniaAudioRecorder.checkPermission();
@@ -59,9 +62,16 @@ if (!hasPermission) {
   await NosniaAudioRecorder.requestPermission();
 }
 
-// Start recording
+// Start recording with real-time duration updates
 await NosniaAudioRecorder.startRecording();
 
+// Add listener for recording duration updates (every 100ms)
+const removeListener = NosniaAudioRecorder.addRecordingProgressListener(
+  ({ duration, isRecording }) => {
+    console.log(`Recording ${Math.floor(duration / 1000)}s`);
+  }
+);
+
 // Pause if needed
 await NosniaAudioRecorder.pauseRecording();
 await NosniaAudioRecorder.resumeRecording();
@@ -73,8 +83,21 @@ console.log(`Recording: ${status.isRecording}, Duration: ${status.duration}ms`);
 // Stop and save
 const filePath = await NosniaAudioRecorder.stopRecording();
 
+// Remove listener when done
+removeListener();
+
 // Or cancel (discard)
 await NosniaAudioRecorder.cancelRecording();
+
+// Play it back
+await NosniaAudioPlayer.startPlaying({ filePath });
+// Optionally listen to progress
+const removePlayback = NosniaAudioPlayer.addPlaybackProgressListener(({ currentTime, duration }) => {
+  console.log(`Progress: ${Math.floor(currentTime / 1000)} / ${Math.floor(duration / 1000)}s`);
+});
+// Stop playback
+await NosniaAudioPlayer.stopPlaying();
+removePlayback();
 ```
 
 ## API Reference
@@ -89,6 +112,22 @@ await NosniaAudioRecorder.cancelRecording();
 - `resumeRecording(): Promise<void>` - Resume recording
 - `cancelRecording(): Promise<void>` - Cancel and discard
 - `getStatus(): Promise<RecorderStatus>` - Get recorder status
+- `addRecordingProgressListener(callback: RecordingProgressCallback): () => void` - Add listener for duration updates (returns cleanup function)
+- `removeRecordingProgressListener(): void` - Remove duration listener
+
+### Player Methods
+
+- `startPlaying(options: PlayOptions): Promise<void>` - Start playing an audio file
+- `stopPlaying(): Promise<void>` - Stop playback and reset
+- `pausePlaying(): Promise<void>` - Pause playback
+- `resumePlaying(): Promise<void>` - Resume playback
+- `seekToTime(time: number): Promise<void>` - Seek to time (seconds)
+- `setVolume(volume: number): Promise<void>` - Set playback volume (0.0–1.0)
+- `getPlayerStatus(): Promise<PlayerStatus>` - Get playback status
+- `addPlaybackProgressListener(callback: PlaybackProgressCallback): () => void` - Listen to playback progress
+- `addPlaybackCompleteListener(callback: () => void): () => void` - Listen for playback completion
+- `removePlaybackProgressListener(): void` - Remove progress listener
+- `removePlaybackCompleteListener(): void` - Remove completion listener
 
 ### Types
 
@@ -105,6 +144,30 @@ interface RecorderStatus {
   duration: number;           // In milliseconds
   currentFilePath?: string;
 }
+
+type RecordingProgressCallback = (data: {
+  duration: number;           // In milliseconds
+  isRecording: boolean;
+}) => void;
+
+interface PlayOptions {
+  filePath: string;
+  volume?: number;  // 0.0 - 1.0
+  loop?: boolean;   // repeat playback
+}
+
+interface PlayerStatus {
+  isPlaying: boolean;
+  duration: number;     // In milliseconds
+  currentTime: number;  // In milliseconds
+  currentFilePath?: string;
+}
+
+type PlaybackProgressCallback = (data: {
+  currentTime: number;
+  duration: number;
+  isPlaying: boolean;
+}) => void;
 ```
 
 ## Platform Setup

package/android/src/main/java/com/nosniaaudiorecorder/NosniaAudioPlayerModule.kt

@@ -0,0 +1,238 @@
+package com.nosniaaudiorecorder
+
+import android.media.MediaPlayer
+import android.os.Handler
+import android.os.Looper
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+
+@ReactModule(name = NosniaAudioPlayerModule.NAME)
+class NosniaAudioPlayerModule(reactContext: ReactApplicationContext) :
+  NativeNosniaAudioPlayerSpec(reactContext) {
+
+  private var mediaPlayer: MediaPlayer? = null
+  private var currentFilePath: String? = null
+  private var isPlaying = false
+  
+  private val progressHandler = Handler(Looper.getMainLooper())
+  private val progressRunnable = object : Runnable {
+    override fun run() {
+      mediaPlayer?.let { player ->
+        if (isPlaying && player.isPlaying) {
+          val currentTime = player.currentPosition.toLong()
+          val duration = player.duration.toLong()
+          
+          sendEvent("onPlaybackProgress", Arguments.createMap().apply {
+            putDouble("currentTime", currentTime.toDouble())
+            putDouble("duration", duration.toDouble())
+            putBoolean("isPlaying", true)
+          })
+          
+          progressHandler.postDelayed(this, 100)
+        }
+      }
+    }
+  }
+  
+  private fun sendEvent(eventName: String, params: WritableMap?) {
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+  
+  private fun startProgressUpdates() {
+    progressHandler.post(progressRunnable)
+  }
+  
+  private fun stopProgressUpdates() {
+    progressHandler.removeCallbacks(progressRunnable)
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  override fun startPlaying(options: ReadableMap, promise: Promise) {
+    try {
+      val filePath = options.getString("filePath")
+      if (filePath == null) {
+        promise.reject("INVALID_PATH", "File path is required")
+        return
+      }
+
+      val volume = if (options.hasKey("volume")) {
+        options.getDouble("volume").toFloat()
+      } else {
+        1.0f
+      }
+
+      val loop = if (options.hasKey("loop")) {
+        options.getBoolean("loop")
+      } else {
+        false
+      }
+
+      // Check if file exists
+      val file = File(filePath)
+      if (!file.exists()) {
+        promise.reject("FILE_NOT_FOUND", "Audio file not found: $filePath")
+        return
+      }
+
+      // Release existing player if any
+      mediaPlayer?.release()
+
+      mediaPlayer = MediaPlayer().apply {
+        setDataSource(filePath)
+        setVolume(volume, volume)
+        isLooping = loop
+        
+        setOnCompletionListener {
+          isPlaying = false
+          stopProgressUpdates()
+          sendEvent("onPlaybackComplete", Arguments.createMap())
+        }
+        
+        setOnErrorListener { _, what, extra ->
+          isPlaying = false
+          stopProgressUpdates()
+          true
+        }
+        
+        prepare()
+        start()
+      }
+
+      isPlaying = true
+      currentFilePath = filePath
+      startProgressUpdates()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      mediaPlayer?.release()
+      mediaPlayer = null
+      isPlaying = false
+      promise.reject("START_PLAYING_ERROR", e.message, e)
+    }
+  }
+
+  override fun stopPlaying(promise: Promise) {
+    try {
+      stopProgressUpdates()
+      
+      mediaPlayer?.apply {
+        if (isPlaying) {
+          stop()
+        }
+        release()
+      }
+      mediaPlayer = null
+      isPlaying = false
+      currentFilePath = null
+      
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("STOP_PLAYING_ERROR", e.message, e)
+    }
+  }
+
+  override fun pausePlaying(promise: Promise) {
+    try {
+      if (!isPlaying || mediaPlayer == null) {
+        promise.reject("NOT_PLAYING", "No playback in progress")
+        return
+      }
+
+      mediaPlayer?.pause()
+      isPlaying = false
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("PAUSE_ERROR", e.message, e)
+    }
+  }
+
+  override fun resumePlaying(promise: Promise) {
+    try {
+      if (isPlaying || mediaPlayer == null) {
+        promise.reject("NOT_PAUSED", "Playback is not paused")
+        return
+      }
+
+      mediaPlayer?.start()
+      isPlaying = true
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("RESUME_ERROR", e.message, e)
+    }
+  }
+
+  override fun seekToTime(time: Double, promise: Promise) {
+    try {
+      if (mediaPlayer == null) {
+        promise.reject("NO_PLAYER", "No audio player initialized")
+        return
+      }
+
+      val timeMs = (time * 1000).toInt()
+      mediaPlayer?.seekTo(timeMs)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("SEEK_ERROR", e.message, e)
+    }
+  }
+
+  override fun setVolume(volume: Double, promise: Promise) {
+    try {
+      if (mediaPlayer == null) {
+        promise.reject("NO_PLAYER", "No audio player initialized")
+        return
+      }
+
+      val volumeFloat = volume.toFloat()
+      mediaPlayer?.setVolume(volumeFloat, volumeFloat)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("SET_VOLUME_ERROR", e.message, e)
+    }
+  }
+
+  override fun getPlayerStatus(promise: Promise) {
+    try {
+      val status = WritableNativeMap().apply {
+        putBoolean("isPlaying", isPlaying)
+        
+        if (mediaPlayer != null) {
+          putDouble("duration", mediaPlayer!!.duration.toDouble())
+          putDouble("currentTime", mediaPlayer!!.currentPosition.toDouble())
+        } else {
+          putDouble("duration", 0.0)
+          putDouble("currentTime", 0.0)
+        }
+        
+        if (currentFilePath != null) {
+          putString("currentFilePath", currentFilePath)
+        }
+      }
+      promise.resolve(status)
+    } catch (e: Exception) {
+      promise.reject("STATUS_ERROR", e.message, e)
+    }
+  }
+
+  override fun onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy()
+    stopProgressUpdates()
+    mediaPlayer?.release()
+    mediaPlayer = null
+  }
+
+  companion object {
+    const val NAME = "NosniaAudioPlayer"
+  }
+}

package/android/src/main/java/com/nosniaaudiorecorder/NosniaAudioRecorderModule.kt

@@ -5,12 +5,16 @@ import android.content.Context
 import android.media.MediaRecorder
 import android.os.Build
 import android.os.Environment
+import android.os.Handler
+import android.os.Looper
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.module.annotations.ReactModule
 import java.io.File
 import java.text.SimpleDateFormat
@@ -25,6 +29,42 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
   private var currentFilePath: String? = null
   private var isRecording = false
   private var isPaused = false
+  private var startTime: Long = 0
+  private var pausedDuration: Long = 0
+  private var pauseStartTime: Long = 0
+  
+  private val progressHandler = Handler(Looper.getMainLooper())
+  private val progressRunnable = object : Runnable {
+    override fun run() {
+      if (isRecording && !isPaused) {
+        val currentTime = System.currentTimeMillis()
+        val duration = currentTime - startTime - pausedDuration
+        
+        sendEvent("onRecordingProgress", Arguments.createMap().apply {
+          putDouble("duration", duration.toDouble())
+          putBoolean("isRecording", true)
+        })
+        
+        progressHandler.postDelayed(this, 100) // Update every 100ms
+      }
+    }
+  }
+  
+  private fun sendEvent(eventName: String, params: WritableMap?) {
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+  
+  private fun startProgressUpdates() {
+    startTime = System.currentTimeMillis()
+    pausedDuration = 0
+    progressHandler.post(progressRunnable)
+  }
+  
+  private fun stopProgressUpdates() {
+    progressHandler.removeCallbacks(progressRunnable)
+  }
 
   override fun getName(): String {
     return NAME
@@ -69,6 +109,7 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
 
       isRecording = true
       isPaused = false
+      startProgressUpdates()
       promise.resolve(null)
     } catch (e: Exception) {
       mediaRecorder?.release()
@@ -85,6 +126,7 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
         return
       }
 
+      stopProgressUpdates()
       mediaRecorder?.apply {
         stop()
         release()
@@ -97,6 +139,7 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
       currentFilePath = null
       promise.resolve(filePath)
     } catch (e: Exception) {
+      stopProgressUpdates()
       mediaRecorder?.release()
       mediaRecorder = null
       isRecording = false
@@ -114,6 +157,7 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
         mediaRecorder?.pause()
         isPaused = true
+        pauseStartTime = System.currentTimeMillis()
         promise.resolve(null)
       } else {
         promise.reject("NOT_SUPPORTED", "Pause is not supported on this API level")
@@ -133,6 +177,7 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
         mediaRecorder?.resume()
         isPaused = false
+        pausedDuration += System.currentTimeMillis() - pauseStartTime
         promise.resolve(null)
       } else {
         promise.reject("NOT_SUPPORTED", "Resume is not supported on this API level")
@@ -144,6 +189,8 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
 
   override fun cancelRecording(promise: Promise) {
     try {
+      stopProgressUpdates()
+      
       mediaRecorder?.apply {
         try {
           stop()
@@ -169,9 +216,20 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
 
   override fun getRecorderStatus(promise: Promise) {
     try {
+      val currentTime = System.currentTimeMillis()
+      val duration = if (isRecording) {
+        if (isPaused) {
+          pauseStartTime - startTime - pausedDuration
+        } else {
+          currentTime - startTime - pausedDuration
+        }
+      } else {
+        0
+      }
+      
       val status = WritableNativeMap().apply {
         putBoolean("isRecording", isRecording)
-        putDouble("duration", mediaRecorder?.currentPosition?.toDouble() ?: 0.0)
+        putDouble("duration", duration.toDouble())
         if (currentFilePath != null) {
           putString("currentFilePath", currentFilePath)
         }

package/android/src/main/java/com/nosniaaudiorecorder/NosniaAudioRecorderPackage.kt

@@ -9,10 +9,10 @@ import java.util.HashMap
 
 class NosniaAudioRecorderPackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == NosniaAudioRecorderModule.NAME) {
-      NosniaAudioRecorderModule(reactContext)
-    } else {
-      null
+    return when (name) {
+      NosniaAudioRecorderModule.NAME -> NosniaAudioRecorderModule(reactContext)
+      NosniaAudioPlayerModule.NAME -> NosniaAudioPlayerModule(reactContext)
+      else -> null
     }
   }
 
@@ -27,6 +27,14 @@ class NosniaAudioRecorderPackage : BaseReactPackage() {
         false,  // isCxxModule
         true // isTurboModule
       )
+      moduleInfos[NosniaAudioPlayerModule.NAME] = ReactModuleInfo(
+        NosniaAudioPlayerModule.NAME,
+        NosniaAudioPlayerModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
       moduleInfos
     }
   }

package/ios/NosniaAudioPlayer.h

@@ -0,0 +1,7 @@
+#import <NosniaAudioPlayerSpec/NosniaAudioPlayerSpec.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface NosniaAudioPlayer : RCTEventEmitter <NativeNosniaAudioPlayerSpec>
+
+@end