react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-9f40b78-20251108

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

@@ -0,0 +1,284 @@
+#include <test/src/biquad/BiquadFilterChromium.h>
+#include <test/src/biquad/BiquadFilterTest.h>
+
+namespace audioapi {
+
+void BiquadFilterTest::expectCoefficientsNear(
+    const std::shared_ptr<BiquadFilterNode> &biquadNode,
+    const BiquadCoefficients &expected) {
+  EXPECT_NEAR(biquadNode->b0_, expected.b0, tolerance);
+  EXPECT_NEAR(biquadNode->b1_, expected.b1, tolerance);
+  EXPECT_NEAR(biquadNode->b2_, expected.b2, tolerance);
+  EXPECT_NEAR(biquadNode->a1_, expected.a1, tolerance);
+  EXPECT_NEAR(biquadNode->a2_, expected.a2, tolerance);
+}
+
+void BiquadFilterTest::testLowpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateLowpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testHighpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateHighpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testBandpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setBandpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateBandpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testNotch(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setNotchCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateNotchCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testAllpass(float frequency, float Q) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setAllpassCoefficients(normalizedFrequency, Q);
+  expectCoefficientsNear(
+      node, calculateAllpassCoefficients(normalizedFrequency, Q));
+}
+
+void BiquadFilterTest::testPeaking(float frequency, float Q, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setPeakingCoefficients(normalizedFrequency, Q, gain);
+  expectCoefficientsNear(
+      node, calculatePeakingCoefficients(normalizedFrequency, Q, gain));
+}
+
+void BiquadFilterTest::testLowshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(
+      node, calculateLowshelfCoefficients(normalizedFrequency, gain));
+}
+
+void BiquadFilterTest::testHighshelf(float frequency, float gain) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setHighshelfCoefficients(normalizedFrequency, gain);
+  expectCoefficientsNear(
+      node, calculateHighshelfCoefficients(normalizedFrequency, gain));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    Frequencies,
+    BiquadFilterFrequencyTest,
+    ::testing::Values(
+        0.0f, // 0 Hz - the filter should block all input signal
+        10.0f, // very low frequency
+        350.0f, // default
+        nyquistFrequency - 0.0001f, // frequency near Nyquist
+        nyquistFrequency)); // maximal frequency
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestLowpassHighpass,
+    ::testing::Values(
+        -770.63678f, // min value for lowpass and highpass
+        0.0f, // default
+        770.63678f)); // max value for lowpass and highpass
+
+INSTANTIATE_TEST_SUITE_P(
+    QEdgeCases,
+    BiquadFilterQTestRestTypes, // bandpass, notch, allpass, peaking
+    ::testing::Values(
+        0.0f, // default and min value
+        MOST_POSITIVE_SINGLE_FLOAT));
+
+INSTANTIATE_TEST_SUITE_P(
+    GainEdgeCases,
+    BiquadFilterGainTest,
+    ::testing::Values(
+        -40.0f,
+        0.0f, // default
+        40.0f));
+
+TEST_P(BiquadFilterFrequencyTest, SetLowpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetBandpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetNotchCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetAllpassCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetPeakingCoefficients) {
+  float frequency = GetParam();
+  float Q = 1.0f;
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetLowshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterFrequencyTest, SetHighshelfCoefficients) {
+  float frequency = GetParam();
+  float gain = 2.0f;
+  testHighshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetLowpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testLowpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestLowpassHighpass, SetHighpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testHighpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetBandpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testBandpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetNotchCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testNotch(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetAllpassCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  testAllpass(frequency, Q);
+}
+
+TEST_P(BiquadFilterQTestRestTypes, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = GetParam();
+  float gain = 2.0f;
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetPeakingCoefficients) {
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float gain = GetParam();
+  testPeaking(frequency, Q, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetLowshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testLowshelf(frequency, gain);
+}
+
+TEST_P(BiquadFilterGainTest, SetHighshelfCoefficients) {
+  float frequency = 1000.0f;
+  float gain = GetParam();
+  testHighshelf(frequency, gain);
+}
+
+TEST_F(BiquadFilterTest, GetFrequencyResponse) {
+  auto node = std::make_shared<BiquadFilterNode>(context.get());
+
+  float frequency = 1000.0f;
+  float Q = 1.0f;
+  float normalizedFrequency = frequency / nyquistFrequency;
+
+  node->setLowpassCoefficients(normalizedFrequency, Q);
+  auto coeffs = calculateLowpassCoefficients(normalizedFrequency, Q);
+
+  std::vector<float> TestFrequencies = {
+      -0.0001f,
+      0.0f,
+      0.0001f,
+      0.25f * nyquistFrequency,
+      0.5f * nyquistFrequency,
+      0.75f * nyquistFrequency,
+      nyquistFrequency - 0.0001f,
+      nyquistFrequency,
+      nyquistFrequency + 0.0001f};
+
+  std::vector<float> magResponseNode(TestFrequencies.size());
+  std::vector<float> phaseResponseNode(TestFrequencies.size());
+  std::vector<float> magResponseExpected(TestFrequencies.size());
+  std::vector<float> phaseResponseExpected(TestFrequencies.size());
+
+  node->getFrequencyResponse(
+      TestFrequencies.data(),
+      magResponseNode.data(),
+      phaseResponseNode.data(),
+      TestFrequencies.size());
+  getFrequencyResponse(
+      coeffs,
+      TestFrequencies,
+      magResponseExpected,
+      phaseResponseExpected,
+      nyquistFrequency);
+
+  for (size_t i = 0; i < TestFrequencies.size(); ++i) {
+    float f = TestFrequencies[i];
+    if (std::isnan(magResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(magResponseNode[i]))
+          << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(magResponseNode[i], magResponseExpected[i], tolerance)
+          << "Magnitude mismatch at " << f << " Hz";
+    }
+
+    if (std::isnan(phaseResponseExpected[i])) {
+      EXPECT_TRUE(std::isnan(phaseResponseNode[i]))
+          << "Expected NaN at frequency " << f;
+    } else {
+      EXPECT_NEAR(phaseResponseNode[i], phaseResponseExpected[i], tolerance)
+          << "Phase mismatch at " << f << " Hz";
+    }
+  }
+}
+
+} // namespace audioapi

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

@@ -0,0 +1,40 @@
+#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

@@ -54,6 +54,8 @@ RCT_EXPORT_MODULE(AudioAPIModule);
 
   _eventHandler = nullptr;
 
+  audioapi::AudioAPIModuleInstaller::closeAllContexts();
+
   [super invalidate];
 }
 
@@ -116,18 +118,25 @@ RCT_EXPORT_METHOD(
     setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
         reject)
 {
-  if ([self.audioSessionManager setActive:enabled]) {
-    resolve(@"true");
-    return;
-  }
-
-  resolve(@"false");
+  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");
+  });
 }
 
 RCT_EXPORT_METHOD(
     setAudioSessionOptions : (NSString *)category mode : (NSString *)mode options : (NSArray *)
         options allowHaptics : (BOOL)allowHaptics)
 {
+  if (!self.audioSessionManager.shouldManageSession) {
+    [self.audioSessionManager setShouldManageSession:true];
+  }
   [self.audioSessionManager setAudioSessionOptions:category mode:mode options:options allowHaptics:allowHaptics];
 }
 
@@ -165,19 +174,30 @@ RCT_EXPORT_METHOD(
     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)
 {
-  [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)
 {
-  [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  });
+}
+
+RCT_EXPORT_METHOD(disableSessionManagement)
+{
+  [self.audioSessionManager disableSessionManagement];
 }
 
 #ifdef RCT_NEW_ARCH_ENABLED
@@ -220,4 +240,9 @@ RCT_EXPORT_METHOD(
   }
 }
 
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_queue_create("swmansion.audioapi.Queue", DISPATCH_QUEUE_SERIAL);
+}
+
 @end

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

@@ -1,11 +1,8 @@
 #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 AudioBufferList;
+#else // when compiled as C++
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
@@ -15,36 +12,21 @@ namespace audioapi {
 
 class AudioBus;
 class CircularAudioArray;
-class IOSAudioFileWriter;
-class IOSRecorderCallback;
-class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
  public:
-  IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-  ~IOSAudioRecorder() override;
-
-  std::string start() override;
-  std::tuple<std::string, double, double> stop() override;
-
-  void enableFileOutput(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags, size_t androidFlags)
-      override;
-  void disableFileOutput() override;
+  IOSAudioRecorder(
+      float sampleRate,
+      int bufferLength,
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
-  void pause() override;
-  void resume() override;
-
-  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
-      override;
-  void clearOnAudioReadyCallback() override;
+  ~IOSAudioRecorder() override;
 
-  double getCurrentDuration() const override;
+  void start() override;
+  void stop() override;
 
  private:
-  std::shared_ptr<IOSAudioFileWriter> fileWriter_;
-  std::shared_ptr<IOSRecorderCallback> callback_;
-  std::string filePath_{""};
-  NativeAudioRecorder *nativeRecorder_;
+  NativeAudioRecorder *audioRecorder_;
 };
 
 } // namespace audioapi

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

@@ -1,157 +1,70 @@
 #import <AVFoundation/AVFoundation.h>
-#import <Foundation/Foundation.h>
-#include <unordered_map>
 
 #include <audioapi/core/utils/Constants.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/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
+#include <unordered_map>
 
 namespace audioapi {
 
-IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
+IOSAudioRecorder::IOSAudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
 {
-  AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (usesFileOutput()) {
-      fileWriter_->writeAudioData(inputBuffer, numFrames);
+  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+    if (isRunning_.load()) {
+      auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
+      writeToBuffers(inputChannel, numFrames);
     }
 
-    if (usesCallback()) {
-      callback_->receiveAudioData(inputBuffer, numFrames);
+    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
+      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
+      auto *outputChannel = bus->getChannel(0)->getData();
+
+      circularBuffer_->pop_front(outputChannel, bufferLength_);
+
+      invokeOnAudioReadyCallback(bus, bufferLength_);
     }
   };
 
-  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
+  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
+                                                         bufferLength:bufferLength
+                                                           sampleRate:sampleRate];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [nativeRecorder_ cleanup];
-}
-std::string IOSAudioRecorder::start()
-{
-  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
-
-  if (isRecording()) {
-    return filePath_;
-  }
-
-  if (usesFileOutput()) {
-    filePath_ = fileWriter_->openFile([nativeRecorder_ getInputFormat], maxInputBufferLength);
-  }
-
-  if (usesCallback()) {
-    callback_->prepare([nativeRecorder_ getInputFormat], maxInputBufferLength);
-  }
-
-  if (isConnected()) {
-    // TODO: set adapter node properties?
-  }
-
-  [nativeRecorder_ start];
-  state_.store(RecorderState::Recording);
-
-  return filePath_;
+  [audioRecorder_ cleanup];
 }
 
-std::tuple<std::string, double, double> IOSAudioRecorder::stop()
+void IOSAudioRecorder::start()
 {
-  std::string filePath = filePath_;
-  double outputFileSize = 0;
-  double outputDuration = 0;
-
-  if (!isRecording()) {
-    return {filePath, 0, 0};
-  }
-
-  [nativeRecorder_ stop];
-  state_.store(RecorderState::Idle);
-
-  if (usesFileOutput()) {
-    auto [size, duration] = fileWriter_->closeFile();
-    outputFileSize = size;
-    outputDuration = duration;
-  }
-
-  if (usesCallback()) {
-    callback_->cleanup();
-  }
-
-  filePath_ = "";
-  return {filePath, outputFileSize, outputDuration};
-}
-
-void IOSAudioRecorder::enableFileOutput(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t iosFlags,
-    size_t androidFlags)
-{
-  fileOutputEnabled_.store(true);
-  fileWriter_ = std::make_shared<IOSAudioFileWriter>(sampleRate, channelCount, bitRate, iosFlags);
-}
-
-void IOSAudioRecorder::disableFileOutput()
-{
-  fileOutputEnabled_.store(false);
-  fileWriter_ = nullptr;
-}
-
-void IOSAudioRecorder::pause()
-{
-  if (!isRecording()) {
+  if (isRunning_.load()) {
     return;
   }
 
-  [nativeRecorder_ stop];
-  state_.store(RecorderState::Paused);
+  [audioRecorder_ start];
+  isRunning_.store(true);
 }
 
-void IOSAudioRecorder::resume()
+void IOSAudioRecorder::stop()
 {
-  if (!isPaused()) {
+  if (!isRunning_.load()) {
     return;
   }
 
-  [nativeRecorder_ start];
-  state_.store(RecorderState::Recording);
-}
-
-void IOSAudioRecorder::setOnAudioReadyCallback(
-    float sampleRate,
-    size_t bufferLength,
-    size_t channelCount,
-    uint64_t callbackId)
-{
-  callback_ = std::make_shared<IOSRecorderCallback>(
-      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
-  callbackOutputEnabled_.store(true);
-}
-
-void IOSAudioRecorder::clearOnAudioReadyCallback()
-{
-  callbackOutputEnabled_.store(false);
-  callback_ = nullptr;
-}
-
-double IOSAudioRecorder::getCurrentDuration() const
-{
-  double duration = 0.0;
-
-  if (usesFileOutput() && fileWriter_) {
-    duration = fileWriter_->getCurrentDuration();
-  }
+  isRunning_.store(false);
+  [audioRecorder_ stop];
 
-  return duration;
+  sendRemainingData();
 }
 
 } // namespace audioapi

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

@@ -7,15 +7,20 @@ 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;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
-
-- (AVAudioFormat *)getInputFormat;
+@property (nonatomic, strong) AVAudioConverter *audioConverter;
+@property (nonatomic, strong) AVAudioFormat *inputFormat;
+@property (nonatomic, strong) AVAudioFormat *outputFormat;
 
-- (int)getBufferSize;
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
+                         bufferLength:(int)bufferLength
+                           sampleRate:(float)sampleRate;
 
 - (void)start;