nosnia-audio-recorder 0.3.0 → 0.3.2

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)
         }
       }

package/ios/NosniaAudioRecorder.mm

@@ -97,60 +97,165 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
                resolve:(RCTPromiseResolveBlock)resolve
                 reject:(RCTPromiseRejectBlock)reject {
   @try {
-    if (_isRecording) {
+    // Safety check: options must not be nil
+    if (!options) {
+      reject(@"INVALID_OPTIONS", @"Options cannot be nil", nil);
+      return;
+    }
+
+    // Prevent concurrent recordings
+    if (_isRecording || _audioRecorder) {
       reject(@"ALREADY_RECORDING", @"Recording is already in progress", nil);
       return;
     }
 
+    // Validate and generate filename
     NSString *filename = options[@"filename"];
-    if (!filename) {
+    if (!filename || ![filename isKindOfClass:[NSString class]] || filename.length == 0) {
       filename = [self generateFilename];
     }
 
+    // Get and validate recording directory
     NSString *recordingDir = [self getRecordingDirectory];
+    if (!recordingDir) {
+      reject(@"DIRECTORY_ERROR", @"Failed to get recording directory", nil);
+      return;
+    }
+
     NSString *filePath = [recordingDir stringByAppendingPathComponent:filename];
+    if (!filePath) {
+      reject(@"PATH_ERROR", @"Invalid file path", nil);
+      return;
+    }
+
+    // Clean up existing file to prevent conflicts
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    [fileManager removeItemAtPath:filePath error:nil];
+
     _recordingURL = [NSURL fileURLWithPath:filePath];
+    if (!_recordingURL) {
+      reject(@"URL_ERROR", @"Failed to create file URL", nil);
+      return;
+    }
+
+    // Validate and sanitize audio parameters
+    NSNumber *bitrate = options[@"bitrate"];
+    if (!bitrate || ![bitrate isKindOfClass:[NSNumber class]] || [bitrate integerValue] <= 0) {
+      bitrate = @(128000);
+    }
 
-    NSNumber *bitrate = options[@"bitrate"] ?: @(128000);
-    NSNumber *channels = options[@"channels"] ?: @(1);
-    NSNumber *sampleRate = options[@"sampleRate"] ?: @(44100);
+    NSNumber *channels = options[@"channels"];
+    if (!channels || ![channels isKindOfClass:[NSNumber class]]) {
+      channels = @(1);
+    } else {
+      NSInteger chCount = [channels integerValue];
+      if (chCount <= 0 || chCount > 2) channels = @(1);
+    }
+
+    NSNumber *sampleRate = options[@"sampleRate"];
+    if (!sampleRate || ![sampleRate isKindOfClass:[NSNumber class]] || [sampleRate integerValue] <= 0) {
+      sampleRate = @(44100);
+    }
 
+    // Get audio session
     AVAudioSession *audioSession = [AVAudioSession sharedInstance];
-    NSError *categoryError = nil;
-    [audioSession setCategory:AVAudioSessionCategoryRecord
-                        error:&categoryError];
-    if (categoryError) {
-      reject(@"AUDIO_SESSION_ERROR", categoryError.description, categoryError);
+    if (!audioSession) {
+      reject(@"AUDIO_SESSION_ERROR", @"Failed to get audio session", nil);
       return;
     }
 
-    NSDictionary *recordingSettings = @{
-      AVFormatIDKey: @(kAudioFormatMPEG4AAC),
-      AVSampleRateKey: sampleRate,
-      AVNumberOfChannelsKey: channels,
-      AVEncoderBitRateKey: bitrate,
-      AVEncoderAudioQualityKey: @(AVAudioQualityMedium)
-    };
+    // Set audio category with device compatibility options
+    NSError *categoryError = nil;
+    BOOL categorySuccess = [audioSession setCategory:AVAudioSessionCategoryRecord
+                                          withOptions:AVAudioSessionCategoryOptionDefaultToSpeaker
+                                                error:&categoryError];
+    if (!categorySuccess || categoryError) {
+      NSString *msg = categoryError ? categoryError.description : @"Failed to set audio category";
+      reject(@"AUDIO_SESSION_ERROR", msg, categoryError);
+      return;
+    }
 
-    NSError *recorderError = nil;
-    _audioRecorder = [[AVAudioRecorder alloc] initWithURL:_recordingURL
-                                                 settings:recordingSettings
-                                                    error:&recorderError];
-    
-    if (recorderError) {
-      reject(@"INIT_RECORDER_ERROR", recorderError.description, recorderError);
+    // Activate audio session
+    NSError *activateError = nil;
+    BOOL activateSuccess = [audioSession setActive:YES error:&activateError];
+    if (!activateSuccess || activateError) {
+      NSString *msg = activateError ? activateError.description : @"Failed to activate audio session";
+      reject(@"AUDIO_SESSION_ERROR", msg, activateError);
       return;
     }
 
-    _audioRecorder.delegate = self;
-    if (![_audioRecorder record]) {
-      reject(@"START_RECORDING_ERROR", @"Failed to start recording", nil);
+    // Validate recording settings dictionary
+    if (!bitrate || !channels || !sampleRate) {
+      reject(@"INVALID_SETTINGS", @"Invalid recording settings", nil);
       return;
     }
 
-    _isRecording = YES;
-    [self startProgressTimer];
-    resolve(nil);
+    // Create recording settings dictionary with safety checks
+    @try {
+      NSDictionary *recordingSettings = @{
+        AVFormatIDKey: @(kAudioFormatMPEG4AAC),
+        AVSampleRateKey: sampleRate,
+        AVNumberOfChannelsKey: channels,
+        AVEncoderBitRateKey: bitrate,
+        AVEncoderAudioQualityKey: @(AVAudioQualityMedium)
+      };
+
+      // Validate settings dictionary created successfully
+      if (!recordingSettings || recordingSettings.count == 0) {
+        reject(@"SETTINGS_ERROR", @"Failed to create recording settings", nil);
+        return;
+      }
+
+      // Validate all required keys are present
+      if (!recordingSettings[AVFormatIDKey] || !recordingSettings[AVSampleRateKey] ||
+          !recordingSettings[AVNumberOfChannelsKey] || !recordingSettings[AVEncoderBitRateKey]) {
+        reject(@"SETTINGS_ERROR", @"Incomplete recording settings", nil);
+        return;
+      }
+
+      // Initialize recorder with error handling
+      NSError *recorderError = nil;
+      _audioRecorder = [[AVAudioRecorder alloc] initWithURL:_recordingURL
+                                                   settings:recordingSettings
+                                                      error:&recorderError];
+      
+      if (recorderError) {
+        NSString *msg = recorderError.description ?: @"Unknown recorder initialization error";
+        reject(@"INIT_RECORDER_ERROR", msg, recorderError);
+        _audioRecorder = nil;
+        return;
+      }
+
+      // Validate recorder was created successfully
+      if (!_audioRecorder) {
+        reject(@"INIT_RECORDER_ERROR", @"AVAudioRecorder initialization returned nil", nil);
+        return;
+      }
+
+      // Set delegate and enable metering
+      _audioRecorder.delegate = self;
+      [_audioRecorder setMeteringEnabled:YES];
+
+      // Attempt to start recording
+      if (![_audioRecorder record]) {
+        NSString *errorMsg = @"Failed to start recording";
+        NSError *recErr = _audioRecorder.error;
+        if (recErr) {
+          errorMsg = [NSString stringWithFormat:@"%s (Error: %@)", errorMsg.UTF8String, recErr.description];
+        }
+        reject(@"START_RECORDING_ERROR", errorMsg, nil);
+        _audioRecorder = nil;
+        return;
+      }
+
+      _isRecording = YES;
+      [self startProgressTimer];
+      resolve(nil);
+    } @catch (NSException *innerException) {
+      reject(@"SETTINGS_ERROR", [NSString stringWithFormat:@"Exception creating settings: %@", innerException.reason], nil);
+      _audioRecorder = nil;
+      _isRecording = NO;
+    }
   } @catch (NSException *exception) {
     reject(@"START_RECORDING_ERROR", exception.reason, nil);
   }
@@ -164,14 +269,42 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
       return;
     }
 
+    // Stop timer and recorder
     [self stopProgressTimer];
-    [_audioRecorder stop];
-    NSString *filePath = [_recordingURL path];
+    
+    // Safely stop the recorder
+    if (_audioRecorder && [_audioRecorder isRecording]) {
+      [_audioRecorder stop];
+    }
+
+    // Get file path before cleaning up recorder
+    NSString *filePath = nil;
+    if (_recordingURL) {
+      filePath = [_recordingURL path];
+      if (!filePath || filePath.length == 0) {
+        filePath = @"";
+      }
+    }
+
+    // Clean up recorder
+    _audioRecorder.delegate = nil;
     _audioRecorder = nil;
     _isRecording = NO;
+    _recordingURL = nil;
+
+    // Validate file exists before returning
+    if (filePath && filePath.length > 0) {
+      NSFileManager *fm = [NSFileManager defaultManager];
+      if ([fm fileExistsAtPath:filePath]) {
+        resolve(filePath);
+        return;
+      }
+    }
 
-    resolve(filePath);
+    resolve(filePath ?: @"");
   } @catch (NSException *exception) {
+    _audioRecorder = nil;
+    _isRecording = NO;
     reject(@"STOP_RECORDING_ERROR", exception.reason, nil);
   }
 }
@@ -184,7 +317,17 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
       return;
     }
 
-    [_audioRecorder pause];
+    // Check if recorder supports pause
+    if (![_audioRecorder respondsToSelector:@selector(pause)]) {
+      reject(@"PAUSE_NOT_SUPPORTED", @"Pause is not supported", nil);
+      return;
+    }
+
+    // Safely pause
+    if ([_audioRecorder isRecording]) {
+      [_audioRecorder pause];
+    }
+
     resolve(nil);
   } @catch (NSException *exception) {
     reject(@"PAUSE_ERROR", exception.reason, nil);
@@ -194,12 +337,29 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
 - (void)resumeRecording:(RCTPromiseResolveBlock)resolve
                  reject:(RCTPromiseRejectBlock)reject {
   @try {
-    if (!_isRecording || !_audioRecorder || [_audioRecorder isRecording]) {
+    if (!_isRecording || !_audioRecorder) {
+      reject(@"NOT_RECORDING", @"No recording in progress", nil);
+      return;
+    }
+
+    // Check if recorder is currently recording (not paused)
+    if ([_audioRecorder isRecording]) {
       reject(@"NOT_PAUSED", @"Recording is not paused", nil);
       return;
     }
 
-    [_audioRecorder record];
+    // Check if recorder supports record method
+    if (![_audioRecorder respondsToSelector:@selector(record)]) {
+      reject(@"RECORD_NOT_SUPPORTED", @"Record is not supported", nil);
+      return;
+    }
+
+    // Resume recording
+    if (![_audioRecorder record]) {
+      reject(@"RESUME_ERROR", @"Failed to resume recording", nil);
+      return;
+    }
+
     resolve(nil);
   } @catch (NSException *exception) {
     reject(@"RESUME_ERROR", exception.reason, nil);
@@ -209,21 +369,41 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
 - (void)cancelRecording:(RCTPromiseResolveBlock)resolve
                  reject:(RCTPromiseRejectBlock)reject {
   @try {
+    // Stop progress timer first
     [self stopProgressTimer];
     
+    // Safely stop recorder
     if (_audioRecorder) {
-      [_audioRecorder stop];
+      if ([_audioRecorder isRecording] || [_audioRecorder isPaused]) {
+        [_audioRecorder stop];
+      }
+      _audioRecorder.delegate = nil;
       _audioRecorder = nil;
     }
 
+    // Clean up recording file
     if (_recordingURL) {
       NSFileManager *fileManager = [NSFileManager defaultManager];
-      [fileManager removeItemAtURL:_recordingURL error:nil];
+      NSString *filePath = [_recordingURL path];
+      if (filePath && [fileManager fileExistsAtPath:filePath]) {
+        NSError *deleteError = nil;
+        [fileManager removeItemAtURL:_recordingURL error:&deleteError];
+        if (deleteError) {
+          // Log but don't fail - file cleanup is not critical
+        }
+      }
       _recordingURL = nil;
     }
 
     _isRecording = NO;
     resolve(nil);
+  } @catch (NSException *exception) {
+    _audioRecorder = nil;
+    _isRecording = NO;
+    reject(@"CANCEL_ERROR", exception.reason, nil);
+  }
+}
+    resolve(nil);
   } @catch (NSException *exception) {
     reject(@"CANCEL_ERROR", exception.reason, nil);
   }
@@ -234,10 +414,23 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
   @try {
     NSMutableDictionary *status = [NSMutableDictionary dictionary];
     status[@"isRecording"] = @(_isRecording);
-    status[@"duration"] = @(_audioRecorder.currentTime * 1000);
+    
+    // Safely get duration
+    double duration = 0.0;
+    if (_audioRecorder) {
+      duration = _audioRecorder.currentTime;
+      if (duration < 0) duration = 0.0;
+    }
+    status[@"duration"] = @(duration * 1000);
+    
+    // Safely get file path
     if (_recordingURL) {
-      status[@"currentFilePath"] = [_recordingURL path];
+      NSString *filePath = [_recordingURL path];
+      if (filePath) {
+        status[@"currentFilePath"] = filePath;
+      }
     }
+    
     resolve(status);
   } @catch (NSException *exception) {
     reject(@"STATUS_ERROR", exception.reason, nil);
@@ -272,14 +465,38 @@ RCT_EXPORT_MODULE(NosniaAudioRecorder)
 
 - (void)audioRecorderDidFinishRecording:(AVAudioRecorder *)recorder
                            successfully:(BOOL)flag {
-  _isRecording = NO;
-  [self stopProgressTimer];
+  @try {
+    if (!flag) {
+      // Recording failed - log but don't crash
+    }
+    
+    _isRecording = NO;
+    [self stopProgressTimer];
+    
+    // Clean up recorder reference
+    if (_audioRecorder == recorder) {
+      _audioRecorder = nil;
+    }
+  } @catch (NSException *exception) {
+    _audioRecorder = nil;
+    _isRecording = NO;
+  }
 }
 
 - (void)audioRecorderEncodeErrorDidOccur:(AVAudioRecorder *)recorder
                                    error:(NSError *)error {
-  _isRecording = NO;
-  [self stopProgressTimer];
+  @try {
+    _isRecording = NO;
+    [self stopProgressTimer];
+    
+    // Clean up recorder reference
+    if (_audioRecorder == recorder) {
+      _audioRecorder = nil;
+    }
+  } @catch (NSException *exception) {
+    _audioRecorder = nil;
+    _isRecording = NO;
+  }
 }
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nosnia-audio-recorder",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "This is a modern audio recorder which actually works cross platform",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",