nosnia-audio-recorder 0.2.0 → 0.3.1

package/README.md

@@ -9,6 +9,7 @@ A compact, high-performance audio recorder library for React Native that records
 - 🎚️ **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
@@ -49,10 +50,10 @@ 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
@@ -87,6 +88,16 @@ 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
@@ -104,6 +115,20 @@ await NosniaAudioRecorder.cancelRecording();
 - `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
 
 ```ts
@@ -124,6 +149,25 @@ 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

@@ -72,39 +72,109 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
 
   override fun startRecording(options: ReadableMap, promise: Promise) {
     try {
+      // Prevent concurrent recordings
       if (isRecording) {
         promise.reject("ALREADY_RECORDING", "Recording is already in progress")
         return
       }
 
-      val filename = options.getString("filename") ?: generateFilename()
-      val bitrate = options.getInt("bitrate").takeIf { it > 0 } ?: 128000
-      val channels = options.getInt("channels").takeIf { it > 0 } ?: 1
-      val sampleRate = options.getInt("sampleRate").takeIf { it > 0 } ?: 44100
+      // Validate and get filename
+      val filename = options.getString("filename")?.takeIf { it.isNotBlank() } ?: generateFilename()
+      
+      // Validate and sanitize audio parameters with bounds checking
+      val bitrate = options.getInt("bitrate").let { 
+        when {
+          it <= 0 -> 128000  // Default
+          it > 320000 -> 320000  // Max reasonable bitrate
+          else -> it
+        }
+      }
+      
+      val channels = options.getInt("channels").let {
+        when {
+          it <= 0 -> 1  // Default to mono
+          it > 2 -> 2  // Max 2 channels (stereo)
+          else -> it
+        }
+      }
+      
+      val sampleRate = options.getInt("sampleRate").let {
+        when {
+          it <= 0 -> 44100  // Default
+          it < 8000 -> 8000  // Min reasonable sample rate
+          it > 48000 -> 48000  // Max reasonable sample rate
+          else -> it
+        }
+      }
 
+      // Get and validate recording directory
       val recordingDir = getRecordingDirectory()
       if (!recordingDir.exists()) {
-        recordingDir.mkdirs()
+        if (!recordingDir.mkdirs()) {
+          promise.reject("DIRECTORY_ERROR", "Failed to create recording directory")
+          return
+        }
+      }
+
+      // Validate directory is writable
+      if (!recordingDir.canWrite()) {
+        promise.reject("DIRECTORY_ERROR", "Recording directory is not writable")
+        return
+      }
+
+      // Create file path
+      val recordingFile = File(recordingDir, filename)
+      currentFilePath = recordingFile.absolutePath
+      
+      if (currentFilePath == null || currentFilePath?.isEmpty() == true) {
+        promise.reject("PATH_ERROR", "Invalid file path")
+        return
       }
 
-      currentFilePath = File(recordingDir, filename).absolutePath
+      // Clean up any existing file
+      try {
+        if (recordingFile.exists()) {
+          recordingFile.delete()
+        }
+      } catch (e: Exception) {
+        // Continue even if cleanup fails
+      }
 
+      // Create and configure media recorder
       mediaRecorder = (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
         MediaRecorder(reactApplicationContext)
       } else {
         @Suppress("DEPRECATION")
         MediaRecorder()
-      }).apply {
-        setAudioSource(MediaRecorder.AudioSource.MIC)
-        // Use MPEG output format for MP3-compatible encoding
-        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
-        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
-        setAudioEncodingBitRate(bitrate)
-        setAudioChannels(channels)
-        setAudioSamplingRate(sampleRate)
-        setOutputFile(currentFilePath)
-        prepare()
-        start()
+      })
+
+      if (mediaRecorder == null) {
+        promise.reject("INIT_RECORDER_ERROR", "Failed to create MediaRecorder instance")
+        return
+      }
+
+      try {
+        mediaRecorder?.apply {
+          setAudioSource(MediaRecorder.AudioSource.MIC)
+          setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+          setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+          setAudioEncodingBitRate(bitrate)
+          setAudioChannels(channels)
+          setAudioSamplingRate(sampleRate)
+          setOutputFile(currentFilePath)
+          
+          // Prepare recorder
+          prepare()
+          
+          // Start recording
+          start()
+        }
+      } catch (e: Exception) {
+        mediaRecorder?.release()
+        mediaRecorder = null
+        currentFilePath = null
+        promise.reject("START_RECORDING_ERROR", e.message ?: "Failed to start recording", e)
+        return
       }
 
       isRecording = true
@@ -115,75 +185,122 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
       mediaRecorder?.release()
       mediaRecorder = null
       isRecording = false
-      promise.reject("START_RECORDING_ERROR", e.message, e)
+      promise.reject("START_RECORDING_ERROR", e.message ?: "Unknown error", e)
     }
   }
 
   override fun stopRecording(promise: Promise) {
     try {
-      if (!isRecording && mediaRecorder == null) {
+      if (!isRecording || mediaRecorder == null) {
         promise.reject("NOT_RECORDING", "No recording in progress")
         return
       }
 
       stopProgressUpdates()
-      mediaRecorder?.apply {
-        stop()
-        release()
+      
+      try {
+        mediaRecorder?.apply {
+          if (isRecording) {
+            stop()
+          }
+          release()
+        }
+      } catch (e: Exception) {
+        // Try to release even if stop fails
+        try {
+          mediaRecorder?.release()
+        } catch (releaseError: Exception) {
+          // Ignore
+        }
       }
+      
       mediaRecorder = null
       isRecording = false
       isPaused = false
 
+      // Validate file exists before returning
       val filePath = currentFilePath ?: ""
+      if (filePath.isNotEmpty()) {
+        try {
+          if (!File(filePath).exists()) {
+            promise.reject("FILE_NOT_FOUND", "Recording file was not created")
+            return
+          }
+        } catch (e: Exception) {
+          // Continue anyway, file might exist
+        }
+      }
+      
       currentFilePath = null
       promise.resolve(filePath)
     } catch (e: Exception) {
       stopProgressUpdates()
-      mediaRecorder?.release()
+      try {
+        mediaRecorder?.release()
+      } catch (releaseError: Exception) {
+        // Ignore
+      }
       mediaRecorder = null
       isRecording = false
-      promise.reject("STOP_RECORDING_ERROR", e.message, e)
+      promise.reject("STOP_RECORDING_ERROR", e.message ?: "Failed to stop recording", e)
     }
   }
 
   override fun pauseRecording(promise: Promise) {
     try {
-      if (!isRecording) {
+      if (!isRecording || mediaRecorder == null) {
         promise.reject("NOT_RECORDING", "No recording in progress")
         return
       }
 
+      if (isPaused) {
+        promise.reject("ALREADY_PAUSED", "Recording is already paused")
+        return
+      }
+
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-        mediaRecorder?.pause()
-        isPaused = true
-        pauseStartTime = System.currentTimeMillis()
-        promise.resolve(null)
+        try {
+          mediaRecorder?.pause()
+          isPaused = true
+          pauseStartTime = System.currentTimeMillis()
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("PAUSE_ERROR", e.message ?: "Failed to pause recording", e)
+        }
       } else {
-        promise.reject("NOT_SUPPORTED", "Pause is not supported on this API level")
+        promise.reject("PAUSE_NOT_SUPPORTED", "Pause is not supported on this Android version")
       }
     } catch (e: Exception) {
-      promise.reject("PAUSE_ERROR", e.message, e)
+      promise.reject("PAUSE_ERROR", e.message ?: "Unknown error during pause", e)
     }
   }
 
   override fun resumeRecording(promise: Promise) {
     try {
-      if (!isRecording || !isPaused) {
+      if (!isRecording || mediaRecorder == null) {
+        promise.reject("NOT_RECORDING", "No recording in progress")
+        return
+      }
+
+      if (!isPaused) {
         promise.reject("NOT_PAUSED", "Recording is not paused")
         return
       }
 
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-        mediaRecorder?.resume()
-        isPaused = false
-        pausedDuration += System.currentTimeMillis() - pauseStartTime
-        promise.resolve(null)
+        try {
+          mediaRecorder?.resume()
+          isPaused = false
+          pausedDuration += System.currentTimeMillis() - pauseStartTime
+          promise.resolve(null)
+        } catch (e: Exception) {
+          promise.reject("RESUME_ERROR", e.message ?: "Failed to resume recording", e)
+        }
       } else {
-        promise.reject("NOT_SUPPORTED", "Resume is not supported on this API level")
+        promise.reject("RESUME_NOT_SUPPORTED", "Resume is not supported on this Android version")
       }
     } catch (e: Exception) {
-      promise.reject("RESUME_ERROR", e.message, e)
+      promise.reject("RESUME_ERROR", e.message ?: "Unknown error during resume", e)
     }
   }
 
@@ -191,46 +308,83 @@ class NosniaAudioRecorderModule(reactContext: ReactApplicationContext) :
     try {
       stopProgressUpdates()
       
-      mediaRecorder?.apply {
+      // Safely stop recorder
+      try {
+        mediaRecorder?.apply {
+          if (isRecording || isPaused) {
+            stop()
+          }
+          release()
+        }
+      } catch (e: Exception) {
+        // Try to release even if stop fails
         try {
-          stop()
-        } catch (e: Exception) {
-          // Might throw if already stopped
+          mediaRecorder?.release()
+        } catch (releaseError: Exception) {
+          // Ignore
         }
-        release()
       }
+      
       mediaRecorder = null
 
+      // Safely delete recording file
       currentFilePath?.let { filePath ->
-        File(filePath).delete()
+        try {
+          val file = File(filePath)
+          if (file.exists()) {
+            file.delete()
+          }
+        } catch (e: Exception) {
+          // Log but don't fail - file cleanup is not critical
+        }
       }
+      
       currentFilePath = null
       isRecording = false
       isPaused = false
+      pausedDuration = 0
+      pauseStartTime = 0
 
       promise.resolve(null)
     } catch (e: Exception) {
-      promise.reject("CANCEL_ERROR", e.message, e)
+      mediaRecorder = null
+      isRecording = false
+      promise.reject("CANCEL_ERROR", e.message ?: "Failed to cancel recording", e)
     }
   }
 
   override fun getRecorderStatus(promise: Promise) {
     try {
       val currentTime = System.currentTimeMillis()
-      val duration = if (isRecording) {
+      
+      // Safely calculate duration
+      val duration = if (isRecording && mediaRecorder != null) {
         if (isPaused) {
-          pauseStartTime - startTime - pausedDuration
+          // Paused: duration = pause time - start time - previous paused duration
+          val pausedDur = pauseStartTime - startTime - pausedDuration
+          if (pausedDur < 0) 0L else pausedDur
         } else {
-          currentTime - startTime - pausedDuration
+          // Recording: duration = current time - start time - previous paused duration
+          val recordingDur = currentTime - startTime - pausedDuration
+          if (recordingDur < 0) 0L else recordingDur
         }
       } else {
-        0
+        0L
       }
       
       val status = WritableNativeMap().apply {
         putBoolean("isRecording", isRecording)
         putDouble("duration", duration.toDouble())
-        if (currentFilePath != null) {
+        if (!currentFilePath.isNullOrEmpty()) {
+          putString("currentFilePath", currentFilePath)
+        }
+      }
+      
+      promise.resolve(status)
+    } catch (e: Exception) {
+      promise.reject("STATUS_ERROR", e.message ?: "Failed to get recorder status", e)
+    }
+  }
           putString("currentFilePath", currentFilePath)
         }
       }