react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.10

package/ios/audioapi/ios/core/IOSAudioPlayer.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as Objective-C++
+#ifdef __OBJC__ // when compiled as Objective-C
 #import <NativeAudioPlayer.h>
-#else // when compiled as C++
+#else  // when compiled as C++
 typedef struct objc_object NativeAudioPlayer;
 #endif // __OBJC__
 

package/ios/audioapi/ios/core/IOSAudioPlayer.mm

@@ -21,7 +21,7 @@ IOSAudioPlayer::IOSAudioPlayer(
     while (processedFrames < numFrames) {
       int framesToProcess = std::min(numFrames - processedFrames, RENDER_QUANTUM_SIZE);
 
-      if (isRunning_.load()) {
+      if (isRunning_.load(std::memory_order_acquire)) {
         renderAudio_(audioBus_, framesToProcess);
       } else {
         audioBus_->zero();
@@ -57,13 +57,13 @@ bool IOSAudioPlayer::start()
   }
 
   bool success = [audioPlayer_ start];
-  isRunning_.store(success);
+  isRunning_.store(success, std::memory_order_release);
   return success;
 }
 
 void IOSAudioPlayer::stop()
 {
-  isRunning_.store(false);
+  isRunning_.store(false, std::memory_order_release);
   [audioPlayer_ stop];
 }
 
@@ -74,13 +74,13 @@ bool IOSAudioPlayer::resume()
   }
 
   bool success = [audioPlayer_ resume];
-  isRunning_.store(success);
+  isRunning_.store(success, std::memory_order_release);
   return success;
 }
 
 void IOSAudioPlayer::suspend()
 {
-  isRunning_.store(false);
+  isRunning_.store(false, std::memory_order_release);
   [audioPlayer_ suspend];
 }
 
@@ -88,7 +88,8 @@ bool IOSAudioPlayer::isRunning() const
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
 
-  return isRunning_.load() && [audioEngine isRunning];
+  return isRunning_.load(std::memory_order_acquire) &&
+      [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
 }
 
 void IOSAudioPlayer::cleanup()

package/ios/audioapi/ios/core/IOSAudioRecorder.h

@@ -1,22 +1,25 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as C++
+#ifdef __OBJC__ // when compiled as Objective-C
 #import <NativeAudioRecorder.h>
 #else
-typedef struct objc_object AVAudioFile;
 typedef struct objc_object NSURL;
+typedef struct objc_object AVAudioFile;
 typedef struct objc_object AudioBufferList;
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
 #include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/utils/Result.hpp>
+
+#include <mutex>
 
 namespace audioapi {
 
-class AudioBus;
-class CircularAudioArray;
-class IOSAudioFileWriter;
-class IOSRecorderCallback;
+class FileWriter;
+class RecorderCallback;
+class RecorderAdapterNode;
+class AudioFileProperties;
 class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
@@ -24,26 +27,31 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~IOSAudioRecorder() override;
 
-  std::string start() override;
-  std::tuple<std::string, double, double> stop() override;
+  Result<std::string, std::string> start() override;
+  Result<std::tuple<std::string, double, double>, std::string> stop() override;
 
-  void enableFileOutput(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags, size_t androidFlags)
-      override;
+  Result<std::string, std::string> enableFileOutput(
+      std::shared_ptr<AudioFileProperties> properties) override;
   void disableFileOutput() override;
 
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node) override;
+  void disconnect() override;
+
   void pause() override;
   void resume() override;
 
-  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
-      override;
-  void clearOnAudioReadyCallback() override;
+  bool isRecording() const override;
+  bool isPaused() const override;
+  bool isIdle() const override;
 
-  double getCurrentDuration() const override;
+  Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) override;
+  void clearOnAudioReadyCallback() override;
 
- private:
-  std::shared_ptr<IOSAudioFileWriter> fileWriter_;
-  std::shared_ptr<IOSRecorderCallback> callback_;
-  std::string filePath_{""};
+ protected:
   NativeAudioRecorder *nativeRecorder_;
 };
 

package/ios/audioapi/ios/core/IOSAudioRecorder.mm

@@ -1,30 +1,61 @@
 #import <AVFoundation/AVFoundation.h>
+#import <AudioEngine.h>
+#import <AudioSessionManager.h>
 #import <Foundation/Foundation.h>
+
 #include <unordered_map>
 
+#include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/utils/AudioFileWriter.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/ios/core/IOSAudioFileWriter.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>
-#include <audioapi/ios/core/IOSRecorderCallback.h>
+#include <audioapi/ios/core/utils/IOSFileWriter.h>
+#include <audioapi/ios/core/utils/IOSRecorderCallback.h>
+#include <audioapi/ios/system/AudioEngine.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <audioapi/utils/Result.hpp>
 
 namespace audioapi {
 
-IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
+/// @brief Constructs an IOSAudioRecorder instance.
+/// This constructor initializes the receiver block and native side recorder wrapper (AVAudioSinkNode).
+/// All other necessary fields (like buffers) are initialized in start() method.
+/// This "method" should be called from the JS thread only.
+/// @param audioEventHandlerRegistry Shared pointer to the AudioEventHandlerRegistry for event handling.
+IOSAudioRecorder::IOSAudioRecorder(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(audioEventHandlerRegistry)
 {
   AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
     if (usesFileOutput()) {
-      fileWriter_->writeAudioData(inputBuffer, numFrames);
+      if (auto lock = Locker::tryLock(fileWriterMutex_)) {
+        std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+            ->writeAudioData(inputBuffer, numFrames);
+      }
     }
 
     if (usesCallback()) {
-      callback_->receiveAudioData(inputBuffer, numFrames);
+      if (auto lock = Locker::tryLock(callbackMutex_)) {
+        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+            ->receiveAudioData(inputBuffer, numFrames);
+      }
+    }
+
+    if (isConnected()) {
+      if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
+        for (size_t channel = 0; channel < adapterNode_->channelCount_; ++channel) {
+          float *channelData = (float *)inputBuffer->mBuffers[channel].mData;
+
+          adapterNode_->buff_[channel]->write(channelData, numFrames);
+        }
+      }
     }
   };
 
@@ -36,84 +67,189 @@ IOSAudioRecorder::~IOSAudioRecorder()
   stop();
   [nativeRecorder_ cleanup];
 }
-std::string IOSAudioRecorder::start()
-{
-  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
 
+/// @brief Starts the audio recording process and prepares necessary resources.
+/// This method should be called from the JS thread only.
+/// @returns Result containing the file path if recording started successfully, or an error message.
+Result<std::string, std::string> IOSAudioRecorder::start()
+{
   if (isRecording()) {
-    return filePath_;
+    return Result<std::string, std::string>::Err("Already recording");
+  }
+
+  std::scoped_lock startLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+  AudioSessionManager *audioSessionManager = [AudioSessionManager sharedInstance];
+
+  if ([[audioSessionManager checkRecordingPermissions] isEqual:@"Denied"]) {
+    return Result<std::string, std::string>::Err("Microphone permissions are not granted");
+  }
+
+  // TODO: recorder should probably request the options if not set by user
+  // but lets handle that in another PR
+  if (![audioSessionManager isSessionActive]) {
+    return Result<std::string, std::string>::Err("Audio session is not active");
   }
 
+  // TODO: this is a bit ugly, and could be written slightly better
+  // we need to stop the audio engine if it's running, to be able to get
+  // proper input format values, otherwise the system my zero out the sample rate or channel count
+  // if input wasn't used yet
+  // (especially on simulators)
+  // Engine will be started again once the native recorder starts
+  [AudioEngine.sharedInstance stopIfNecessary];
+
+  // Estimate the maximum input buffer lengths that can be expected from the sink node
+  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
+  auto inputFormat = [nativeRecorder_ getInputFormat];
+
   if (usesFileOutput()) {
-    filePath_ = fileWriter_->openFile([nativeRecorder_ getInputFormat], maxInputBufferLength);
+    auto fileResult = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+                          ->openFile(inputFormat, maxInputBufferLength);
+
+    if (fileResult.is_err()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + fileResult.unwrap_err());
+    }
+
+    filePath_ = fileResult.unwrap();
   }
 
   if (usesCallback()) {
-    callback_->prepare([nativeRecorder_ getInputFormat], maxInputBufferLength);
+    auto callbackResult = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+                              ->prepare(inputFormat, maxInputBufferLength);
+
+    if (callbackResult.is_err()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to prepare callback: " + callbackResult.unwrap_err());
+    }
   }
 
   if (isConnected()) {
-    // TODO: set adapter node properties?
+    // TODO: pass sample rate, in case conversion is necessary
+    adapterNode_->init(maxInputBufferLength, inputFormat.channelCount);
   }
 
   [nativeRecorder_ start];
-  state_.store(RecorderState::Recording);
-
-  return filePath_;
+  state_.store(RecorderState::Recording, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
 }
 
-std::tuple<std::string, double, double> IOSAudioRecorder::stop()
+/// @brief Stops the audio recording process and releases resources.
+/// It finalizes any data receiver and closes the stream.
+/// This method should be called from the JS thread only.
+/// @returns Result containing a tuple of the output file path, size, and duration if stopped successfully, or an error message.
+Result<std::tuple<std::string, double, double>, std::string> IOSAudioRecorder::stop()
 {
+  std::scoped_lock stopLock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
+
   std::string filePath = filePath_;
   double outputFileSize = 0;
   double outputDuration = 0;
 
-  if (!isRecording()) {
-    return {filePath, 0, 0};
+  if (isIdle()) {
+    return Result<std::tuple<std::string, double, double>, std::string>::Err(
+        "Recorder is not in recording state.");
   }
 
+  state_.store(RecorderState::Idle, std::memory_order_release);
   [nativeRecorder_ stop];
-  state_.store(RecorderState::Idle);
 
   if (usesFileOutput()) {
-    auto [size, duration] = fileWriter_->closeFile();
-    outputFileSize = size;
-    outputDuration = duration;
+    auto fileResult = fileWriter_->closeFile();
+
+    if (fileResult.is_err()) {
+      return Result<std::tuple<std::string, double, double>, std::string>::Err(
+          "Failed to close file: " + fileResult.unwrap_err());
+    }
+
+    outputFileSize = std::get<0>(fileResult.unwrap());
+    outputDuration = std::get<1>(fileResult.unwrap());
   }
 
   if (usesCallback()) {
-    callback_->cleanup();
+    dataCallback_->cleanup();
+  }
+
+  if (isConnected()) {
+    adapterNode_->cleanup();
   }
 
   filePath_ = "";
-  return {filePath, outputFileSize, outputDuration};
+  return Result<std::tuple<std::string, double, double>, std::string>::Ok(
+      std::make_tuple(filePath, outputFileSize, outputDuration));
 }
 
-void IOSAudioRecorder::enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags)
+/// @brief Enables file output for the recorder with specified properties.
+/// If the recorder is already active, it will open the file for writing immediately.
+/// This method should be called from the JS thread only.
+/// @param properties Shared pointer to AudioFileProperties defining the output file format.
+/// @returns Result containing the output file path if enabled successfully, or an error message.
+Result<std::string, std::string> IOSAudioRecorder::enableFileOutput(
+    std::shared_ptr<AudioFileProperties> properties)
 {
-  fileOutputEnabled_.store(true);
-  fileWriter_ = std::make_shared<IOSAudioFileWriter>(sampleRate, channelCount, bitRate, iosFlags);
+  std::scoped_lock lock(fileWriterMutex_, errorCallbackMutex_);
+  fileWriter_ = std::make_shared<IOSFileWriter>(audioEventHandlerRegistry_, properties);
+
+  if (!isIdle()) {
+    auto result = std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+                      ->openFile([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
+
+    if (result.is_err()) {
+      return Result<std::string, std::string>::Err(
+          "Failed to open file for writing: " + result.unwrap_err());
+    }
+
+    filePath_ = result.unwrap();
+  }
+
+  fileWriter_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
+
+  fileOutputEnabled_.store(true, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
 }
 
 void IOSAudioRecorder::disableFileOutput()
 {
-  fileOutputEnabled_.store(false);
+  std::scoped_lock lock(fileWriterMutex_);
+  fileOutputEnabled_.store(false, std::memory_order_release);
   fileWriter_ = nullptr;
 }
 
+/// @brief Connects a RecorderAdapterNode to the recorder for audio data routing.
+/// If the recorder is already active, it will initialize the adapter node immediately.
+/// This method should be called from the JS thread only.
+/// @param node Shared pointer to the RecorderAdapterNode to connect.
+void IOSAudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node)
+{
+  std::scoped_lock lock(adapterNodeMutex_);
+  adapterNode_ = node;
+
+  if (!isIdle()) {
+    adapterNode_->init(
+        [nativeRecorder_ getBufferSize], [nativeRecorder_ getInputFormat].channelCount);
+  }
+
+  isConnected_.store(true, std::memory_order_release);
+}
+
+/// @brief Disconnects the currently connected RecorderAdapterNode from the recorder.
+/// If the recorder is currently active, it will stop routing audio data immediately.
+/// This method should be called from the JS thread only.
+void IOSAudioRecorder::disconnect()
+{
+  std::scoped_lock lock(adapterNodeMutex_);
+  adapterNode_ = nullptr;
+  isConnected_.store(false, std::memory_order_release);
+}
+
 void IOSAudioRecorder::pause()
 {
   if (!isRecording()) {
     return;
   }
 
-  [nativeRecorder_ stop];
-  state_.store(RecorderState::Paused);
+  [nativeRecorder_ pause];
+  state_.store(RecorderState::Paused, std::memory_order_release);
 }
 
 void IOSAudioRecorder::resume()
@@ -122,36 +258,90 @@ void IOSAudioRecorder::resume()
     return;
   }
 
-  [nativeRecorder_ start];
-  state_.store(RecorderState::Recording);
+  [nativeRecorder_ resume];
+  state_.store(RecorderState::Recording, std::memory_order_release);
 }
 
-void IOSAudioRecorder::setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId)
+/// @brief Checks if the recorder is currently recording.
+/// Besides recorder internal state, it also check if the audio engine is running.
+/// this helps with restarts after interruptions or other audio session changes.
+/// This method can be called from any thread.
+/// @returns True if recording, false otherwise.
+bool IOSAudioRecorder::isRecording() const
 {
-  callback_ = std::make_shared<IOSRecorderCallback>(
-      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
-  callbackOutputEnabled_.store(true);
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
+      [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
 }
 
-void IOSAudioRecorder::clearOnAudioReadyCallback()
+/// @brief Checks if the recorder is currently paused.
+/// Besides recorder internal state, it also check if the audio engine is running.
+/// this helps with restarts after interruptions or other audio session changes.
+/// This method can be called from any thread.
+/// @returns True if paused, false otherwise.
+bool IOSAudioRecorder::isPaused() const
 {
-  callbackOutputEnabled_.store(false);
-  callback_ = nullptr;
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  auto currentState = state_.load(std::memory_order_acquire);
+
+  if (currentState == RecorderState::Idle) {
+    return false;
+  }
+
+  return currentState == RecorderState::Paused ||
+      [audioEngine getState] != AudioEngineState::AudioEngineStateRunning;
 }
 
-double IOSAudioRecorder::getCurrentDuration() const
+/// @brief Checks if the recorder is currently idle (not recording or paused).
+/// This method can be called from any thread.
+/// @returns True if idle, false otherwise.
+bool IOSAudioRecorder::isIdle() const
 {
-  double duration = 0.0;
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
 
-  if (usesFileOutput() && fileWriter_) {
-    duration = fileWriter_->getCurrentDuration();
+/// @brief Sets the callback to be invoked when audio data is ready.
+/// If the recorder is already active, it will prepare the callback for receiving audio data immediately.
+/// This method should be called from the JS thread only.
+/// @param sampleRate Desired sample rate for the callback audio data.
+/// @param bufferLength Desired buffer length in frames for the callback audio data.
+/// @param channelCount Number of channels for the callback audio data.
+/// @param callbackId Identifier for the JS callback to be invoked.
+/// @returns Success status or Error status with message.
+Result<NoneType, std::string> IOSAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+{
+  std::scoped_lock lock(callbackMutex_, errorCallbackMutex_);
+
+  dataCallback_ = std::make_shared<IOSRecorderCallback>(
+      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
+
+  if (!isIdle()) {
+    auto result = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+                      ->prepare([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
+
+    if (result.is_err()) {
+      return Result<NoneType, std::string>::Err(result.unwrap_err());
+    }
   }
 
-  return duration;
+  dataCallback_->setOnErrorCallback(errorCallbackId_.load(std::memory_order_acquire));
+
+  callbackOutputEnabled_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @brief Clears the audio data callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void IOSAudioRecorder::clearOnAudioReadyCallback()
+{
+  std::scoped_lock lock(callbackMutex_);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
 }
 
 } // namespace audioapi

package/ios/audioapi/ios/core/NativeAudioPlayer.m

@@ -15,7 +15,10 @@
 
     __weak typeof(self) weakSelf = self;
     self.renderBlock = ^OSStatus(
-        BOOL *isSilence, const AudioTimeStamp *timestamp, AVAudioFrameCount frameCount, AudioBufferList *outputData) {
+        BOOL *isSilence,
+        const AudioTimeStamp *timestamp,
+        AVAudioFrameCount frameCount,
+        AudioBufferList *outputData) {
       if (outputData->mNumberBuffers != weakSelf.channelCount) {
         return kAudioServicesBadPropertySizeError;
       }
@@ -25,8 +28,10 @@
       return kAudioServicesNoError;
     };
 
-    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate channels:self.channelCount];
-    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format renderBlock:self.renderBlock];
+    _format = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.sampleRate
+                                                             channels:self.channelCount];
+    _sourceNode = [[AVAudioSourceNode alloc] initWithFormat:self.format
+                                                renderBlock:self.renderBlock];
   }
 
   return self;
@@ -34,37 +39,34 @@
 
 - (bool)start
 {
-  NSLog(@"[AudioPlayer] start");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
-  // AudioEngine allows us to attach and connect nodes at runtime but with few limitations
-  // in this case if it is the first player and recorder started the engine we need to restart.
-  // It can be optimized by tracking if we haven't break rules of at runtime modifications from docs
+  // AudioEngine allows us to attach and connect nodes at runtime but with few
+  // limitations in this case if it is the first player and recorder started the
+  // engine we need to restart. It can be optimized by tracking if we haven't
+  // break rules of at runtime modifications from docs
   // https://developer.apple.com/documentation/avfaudio/avaudioengine?language=objc
   //
   // Currently we are restarting because we do not see any significant performance issue and case when
   // you will need to start and stop player very frequently
-  [audioEngine stopEngine];
+  [audioEngine stopIfNecessary];
   self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
   return [audioEngine startIfNecessary];
 }
 
 - (void)stop
 {
-  NSLog(@"[AudioPlayer] stop");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
+
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
-  [audioEngine stopIfNecessary];
+  [audioEngine stopIfPossible];
   self.sourceNodeId = nil;
 }
 
 - (bool)resume
 {
-  NSLog(@"[AudioPlayer] resume");
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -75,7 +77,8 @@
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine pauseEngine:self.sourceNodeId];
+
+  [audioEngine pauseIfNecessary];
 }
 
 - (void)cleanup

package/ios/audioapi/ios/core/NativeAudioRecorder.h

@@ -21,6 +21,10 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 - (void)stop;
 
+- (void)pause;
+
+- (void)resume;
+
 - (void)cleanup;
 
 @end