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

package/common/cpp/test/src/biquad/BiquadFilterTest.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+#include <memory>
+
+static constexpr int sampleRate = 44100;
+static constexpr float nyquistFrequency = sampleRate / 2.0f;
+static constexpr float tolerance = 0.0001f;
+
+namespace audioapi {
+class BiquadFilterTest : public ::testing::Test {
+ protected:
+  std::shared_ptr<MockAudioEventHandlerRegistry> eventRegistry;
+  std::unique_ptr<OfflineAudioContext> context;
+
+  void SetUp() override {
+    eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+    context = std::make_unique<OfflineAudioContext>(
+        2, 5 * sampleRate, sampleRate, eventRegistry, RuntimeRegistry{});
+  }
+
+  void expectCoefficientsNear(
+      const std::shared_ptr<BiquadFilterNode> &node,
+      const BiquadCoefficients &expected);
+  void testLowpass(float frequency, float Q);
+  void testHighpass(float frequency, float Q);
+  void testBandpass(float frequency, float Q);
+  void testNotch(float frequency, float Q);
+  void testAllpass(float frequency, float Q);
+  void testPeaking(float frequency, float Q, float gain);
+  void testLowshelf(float frequency, float gain);
+  void testHighshelf(float frequency, float gain);
+};
+
+class BiquadFilterQTestLowpassHighpass : public BiquadFilterTest,
+                                         public ::testing::WithParamInterface<float> {};
+class BiquadFilterQTestRestTypes : public BiquadFilterTest,
+                                   public ::testing::WithParamInterface<float> {};
+class BiquadFilterFrequencyTest : public BiquadFilterTest,
+                                  public ::testing::WithParamInterface<float> {};
+class BiquadFilterGainTest : public BiquadFilterTest,
+                             public ::testing::WithParamInterface<float> {};
+} // namespace audioapi

package/ios/audioapi/ios/AudioAPIModule.h

@@ -1,5 +1,6 @@
 #ifdef RCT_NEW_ARCH_ENABLED
 #import <React/RCTCallInvokerModule.h>
+#import <React/RCTInvalidating.h>
 #import <rnaudioapi/rnaudioapi.h>
 #else // RCT_NEW_ARCH_ENABLED
 #import <React/RCTBridgeModule.h>
@@ -14,7 +15,7 @@
 
 @interface AudioAPIModule : RCTEventEmitter
 #ifdef RCT_NEW_ARCH_ENABLED
-                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule>
+                            <NativeAudioAPIModuleSpec, RCTCallInvokerModule, RCTInvalidating>
 #else
                             <RCTBridgeModule>
 #endif // RCT_NEW_ARCH_ENABLED

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -26,7 +26,7 @@ using namespace worklets;
 
 #if defined(RCT_NEW_ARCH_ENABLED)
 // nothing
-#else // defined(RCT_NEW_ARCH_ENABLED)
+#else  // defined(RCT_NEW_ARCH_ENABLED)
 @interface RCTBridge (RCTTurboModule)
 - (std::shared_ptr<facebook::react::CallInvoker>)jsCallInvoker;
 - (void)_tryAndHandleError:(dispatch_block_t)block;
@@ -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.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
   self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
 
@@ -68,7 +73,7 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 
 #if defined(RCT_NEW_ARCH_ENABLED)
   auto jsCallInvoker = _callInvoker.callInvoker;
-#else // defined(RCT_NEW_ARCH_ENABLED)
+#else  // defined(RCT_NEW_ARCH_ENABLED)
   auto jsCallInvoker = self.bridge.jsCallInvoker;
 #endif // defined(RCT_NEW_ARCH_ENABLED)
 
@@ -98,13 +103,14 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
   }
 
   // Get the actual JSI Runtime reference
-  audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
+  audioapi::AudioAPIModuleInstaller::injectJSIBindings(
+      jsiRuntime, jsCallInvoker, _eventHandler, uiWorkletRuntime);
 #else
   audioapi::AudioAPIModuleInstaller::injectJSIBindings(jsiRuntime, jsCallInvoker, _eventHandler);
 #endif
 
   NSLog(@"Successfully installed JSI bindings for react-native-audio-api!");
-  return @true;
+  return @YES;
 }
 
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
@@ -113,22 +119,27 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDevicePreferredSampleRate)
 }
 
 RCT_EXPORT_METHOD(
-    setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
-        reject)
+    setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)
+        resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  if ([self.audioSessionManager setActive:enabled]) {
-    resolve(@"true");
-    return;
-  }
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    auto success = [self.audioSessionManager setActive:enabled];
 
-  resolve(@"false");
+    resolve(@(success));
+  });
 }
 
 RCT_EXPORT_METHOD(
     setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
         options allowHaptics : (BOOL)allowHaptics)
 {
-  [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options allowHaptics:allowHaptics];
+  if (!self.audioSessionManager.shouldManageSession) {
+    [self.audioSessionManager setShouldManageSession:true];
+  }
+  [self.audioSessionManager setAudioSessionOptions:category
+                                              mode:mode
+                                           options:options
+                                      allowHaptics:allowHaptics];
 }
 
 RCT_EXPORT_METHOD(setLockScreenInfo : (NSDictionary *)info)
@@ -162,22 +173,35 @@ RCT_EXPORT_METHOD(observeVolumeChanges : (BOOL)enabled)
 }
 
 RCT_EXPORT_METHOD(
-    requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)
-        reject)
+    requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(
-    checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+    checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(
-    getDevicesInfo : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+    getDevicesInfo : (nonnull RCTPromiseResolveBlock)
+        resolve reject : (nonnull RCTPromiseRejectBlock)reject)
+{
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  });
+}
+
+RCT_EXPORT_METHOD(disableSessionManagement)
 {
-  [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  [self.audioSessionManager disableSessionManagement];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED

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,56 @@
 #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)
+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::dynamic_pointer_cast<IOSFileWriter>(fileWriter_)
+            ->writeAudioData(inputBuffer, numFrames);
+      }
     }
 
     if (usesCallback()) {
-      callback_->receiveAudioData(inputBuffer, numFrames);
+      if (auto lock = Locker::tryLock(callbackMutex_)) {
+        std::dynamic_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 +62,168 @@ IOSAudioRecorder::~IOSAudioRecorder()
   stop();
   [nativeRecorder_ cleanup];
 }
-std::string IOSAudioRecorder::start()
-{
-  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
 
+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 activating the session and setting 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];
+
+  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
+  auto inputFormat = [nativeRecorder_ getInputFormat];
+
   if (usesFileOutput()) {
-    filePath_ = fileWriter_->openFile([nativeRecorder_ getInputFormat], maxInputBufferLength);
+    auto fileResult = std::dynamic_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::dynamic_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()
+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};
+    return Result<std::tuple<std::string, double, double>, std::string>::Err("Not recording");
   }
 
+  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)
+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::dynamic_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;
 }
 
+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);
+}
+
+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 +232,66 @@ 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)
+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()
+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
+bool IOSAudioRecorder::isIdle() const
 {
-  double duration = 0.0;
+  return state_.load(std::memory_order_acquire) == RecorderState::Idle;
+}
 
-  if (usesFileOutput() && fileWriter_) {
-    duration = fileWriter_->getCurrentDuration();
+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::dynamic_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);
+}
+
+void IOSAudioRecorder::clearOnAudioReadyCallback()
+{
+  std::scoped_lock lock(callbackMutex_);
+  callbackOutputEnabled_.store(false, std::memory_order_release);
+  dataCallback_ = nullptr;
 }
 
 } // namespace audioapi