react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-52d0b79-20251216

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -57,10 +57,15 @@ RCT_EXPORT_MODULE(AudioAPIModule);
   [super invalidate];
 }
 
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_queue_create("com.swmansion.audioapi.MainModuleQueue", DISPATCH_QUEUE_SERIAL);
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   self.audioSessionManager = [[AudioSessionManager alloc] init];
-  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.audioEngine = [[AudioEngine alloc] init];
   self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
   self.notificationRegistry = [[NotificationRegistry alloc] initWithAudioAPIModule:self];
 
@@ -118,14 +123,9 @@ RCT_EXPORT_METHOD(
         resolve reject : (RCTPromiseRejectBlock)reject)
 {
   dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-    if (!self.audioSessionManager.shouldManageSession) {
-      [self.audioSessionManager setShouldManageSession:true];
-    }
-    if ([self.audioSessionManager setActive:enabled]) {
-      resolve(@"true");
-      return;
-    }
-    resolve(@"false");
+    auto success = [self.audioSessionManager setActive:enabled];
+
+    resolve(@(success));
   });
 }
 
@@ -334,9 +334,4 @@ RCT_EXPORT_METHOD(
   }
 }
 
-- (dispatch_queue_t)methodQueue
-{
-  return dispatch_queue_create("swmansion.audioapi.Queue", DISPATCH_QUEUE_SERIAL);
-}
-
 @end

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

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

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,32 +1,58 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as Objective-C++
+#ifdef __OBJC__ // when compiled as Objective-C
 #import <NativeAudioRecorder.h>
-#else  // when compiled as C++
+#else
+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 FileWriter;
+class RecorderCallback;
+class RecorderAdapterNode;
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
  public:
-  IOSAudioRecorder(
-      float sampleRate,
-      int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-
+  IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~IOSAudioRecorder() override;
 
-  void start() override;
-  void stop() override;
+  Result<std::string, std::string> start() override;
+  Result<std::tuple<std::string, double, double>, std::string> stop() 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;
+
+  bool isRecording() const override;
+  bool isPaused() const override;
+  bool isIdle() const override;
+
+  Result<NoneType, std::string> setOnAudioReadyCallback(
+      float sampleRate,
+      size_t bufferLength,
+      int channelCount,
+      uint64_t callbackId) override;
+  void clearOnAudioReadyCallback() override;
 
- private:
-  NativeAudioRecorder *audioRecorder_;
+ protected:
+  NativeAudioRecorder *nativeRecorder_;
 };
 
 } // namespace audioapi

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

@@ -1,70 +1,346 @@
 #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/IOSAudioRecorder.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 <unordered_map>
+#include <audioapi/utils/Result.hpp>
 
 namespace audioapi {
 
+/// @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(
-    float sampleRate,
-    int bufferLength,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
+    : AudioRecorder(audioEventHandlerRegistry)
 {
-  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (isRunning_.load()) {
-      auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-      writeToBuffers(inputChannel, numFrames);
+  AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+    if (usesFileOutput()) {
+      if (auto lock = Locker::tryLock(fileWriterMutex_)) {
+        std::static_pointer_cast<IOSFileWriter>(fileWriter_)
+            ->writeAudioData(inputBuffer, numFrames);
+      }
     }
 
-    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-      auto *outputChannel = bus->getChannel(0)->getData();
+    if (usesCallback()) {
+      if (auto lock = Locker::tryLock(callbackMutex_)) {
+        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+            ->receiveAudioData(inputBuffer, numFrames);
+      }
+    }
 
-      circularBuffer_->pop_front(outputChannel, bufferLength_);
+    if (isConnected()) {
+      if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
+        for (size_t channel = 0; channel < adapterNode_->channelCount_; ++channel) {
+          float *channelData = (float *)inputBuffer->mBuffers[channel].mData;
 
-      invokeOnAudioReadyCallback(bus, bufferLength_);
+          adapterNode_->buff_[channel]->write(channelData, numFrames);
+        }
+      }
     }
   };
 
-  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
-                                                         bufferLength:bufferLength
-                                                           sampleRate:sampleRate];
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [audioRecorder_ cleanup];
+  [nativeRecorder_ cleanup];
+}
+
+/// @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 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()) {
+    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()) {
+    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: pass sample rate, in case conversion is necessary
+    adapterNode_->init(maxInputBufferLength, inputFormat.channelCount);
+  }
+
+  [nativeRecorder_ start];
+  state_.store(RecorderState::Recording, std::memory_order_release);
+  return Result<std::string, std::string>::Ok(filePath_);
+}
+
+/// @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 (isIdle()) {
+    return Result<std::tuple<std::string, double, double>, std::string>::Err("Not recording");
+  }
+
+  state_.store(RecorderState::Idle, std::memory_order_release);
+  [nativeRecorder_ stop];
+
+  if (usesFileOutput()) {
+    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()) {
+    dataCallback_->cleanup();
+  }
+
+  if (isConnected()) {
+    adapterNode_->cleanup();
+  }
+
+  filePath_ = "";
+  return Result<std::tuple<std::string, double, double>, std::string>::Ok(
+      std::make_tuple(filePath, outputFileSize, outputDuration));
+}
+
+/// @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)
+{
+  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()
+{
+  std::scoped_lock lock(fileWriterMutex_);
+  fileOutputEnabled_.store(false, std::memory_order_release);
+  fileWriter_ = nullptr;
 }
 
-void IOSAudioRecorder::start()
+/// @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)
 {
-  if (isRunning_.load()) {
+  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;
   }
 
-  [audioRecorder_ start];
-  isRunning_.store(true);
+  [nativeRecorder_ pause];
+  state_.store(RecorderState::Paused, std::memory_order_release);
 }
 
-void IOSAudioRecorder::stop()
+void IOSAudioRecorder::resume()
 {
-  if (!isRunning_.load()) {
+  if (!isPaused()) {
     return;
   }
 
-  isRunning_.store(false);
-  [audioRecorder_ stop];
+  [nativeRecorder_ resume];
+  state_.store(RecorderState::Recording, std::memory_order_release);
+}
+
+/// @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
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  return state_.load(std::memory_order_acquire) == RecorderState::Recording &&
+      [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
+}
+
+/// @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
+{
+  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;
+}
+
+/// @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
+{
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
 
-  sendRemainingData();
+/// @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());
+    }
+  }
+
+  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

@@ -39,8 +39,6 @@
 
 - (bool)start
 {
-  NSLog(@"[AudioPlayer] start");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -50,28 +48,25 @@
   // 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];
+  // 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 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);
 
@@ -82,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

@@ -7,25 +7,24 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 @interface NativeAudioRecorder : NSObject
 
-@property (nonatomic, assign) int bufferLength;
-@property (nonatomic, assign) float sampleRate;
-
 @property (nonatomic, strong) AVAudioSinkNode *sinkNode;
 @property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverSinkBlock;
 @property (nonatomic, copy) AudioReceiverBlock receiverBlock;
 
-@property (nonatomic, strong) AVAudioConverter *audioConverter;
-@property (nonatomic, strong) AVAudioFormat *inputFormat;
-@property (nonatomic, strong) AVAudioFormat *outputFormat;
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
+
+- (AVAudioFormat *)getInputFormat;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate;
+- (int)getBufferSize;
 
 - (void)start;
 
 - (void)stop;
 
+- (void)pause;
+
+- (void)resume;
+
 - (void)cleanup;
 
 @end