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

package/ios/audioapi/ios/core/IOSAudioFileWriter.mm

@@ -4,6 +4,8 @@
 #include <audioapi/ios/core/IOSAudioFileOptions.h>
 #include <audioapi/ios/core/IOSAudioFileWriter.h>
 
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
 namespace audioapi {
 IOSAudioFileWriter::IOSAudioFileWriter(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags)
 {
@@ -18,13 +20,14 @@ IOSAudioFileWriter::~IOSAudioFileWriter()
   bufferFormat_ = nil;
 }
 
-void IOSAudioFileWriter::openFile(AVAudioFormat *bufferFormat)
+std::string IOSAudioFileWriter::openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
 {
   @autoreleasepool {
     if (audioFile_ != nil) {
       NSLog(@"⚠️ createFileForWriting: currentAudioFile_ already exists");
-      return;
+      return "";
     }
+    framesWritten_.store(0);
 
     bufferFormat_ = bufferFormat;
 
@@ -44,28 +47,59 @@ void IOSAudioFileWriter::openFile(AVAudioFormat *bufferFormat)
     converter_.sampleRateConverterQuality = AVAudioQualityMax;
     converter_.primeMethod = AVAudioConverterPrimeMethod_None;
 
-    NSLog(@"buferFormat: %@ fileFormat: %@", bufferFormat, [audioFile_ processingFormat]);
+    converterInputBufferSize_ = maxInputBufferLength;
+    converterOutputBufferSize_ = std::max(
+        (double)maxInputBufferLength, fileOptions_->getSampleRate() / bufferFormat.sampleRate * maxInputBufferLength);
+
+    converterInputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat
+                                                          frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
+    converterOutputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile_ processingFormat]
+                                                           frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
 
     if (error != nil || audioFile_ == nil) {
       NSLog(@"Error creating audio file for writing: %@", [error debugDescription]);
       audioFile_ = nil;
+
+      return "";
     }
+
+    return [[fileURL_ path] UTF8String];
   }
 }
 
-std::string IOSAudioFileWriter::closeFile()
+std::tuple<double, double> IOSAudioFileWriter::closeFile()
 {
   @autoreleasepool {
+    NSError *error;
     std::string filePath = [[fileURL_ path] UTF8String];
 
     if (audioFile_ == nil) {
-      return "";
+      return {0, 0};
     }
 
     // AVAudioFile automatically finalizes the file when deallocated
     audioFile_ = nil;
+
+    double fileDuration = CMTimeGetSeconds([[AVURLAsset URLAssetWithURL:fileURL_ options:nil] duration]);
+    double fileSizeBytesMb =
+        static_cast<double>([[[NSFileManager defaultManager] attributesOfItemAtPath:fileURL_.path
+                                                                              error:&error] fileSize]) /
+        BYTES_TO_MB;
+
+    NSLog(
+        @"ℹ️ Closed audio file at path: %s, duration: %.2f sec, size: %.2f MB",
+        filePath.c_str(),
+        fileDuration,
+        fileSizeBytesMb);
+
+    if (error != nil) {
+      NSLog(@"⚠️ closeFile: error while retrieving file size");
+      fileSizeBytesMb = 0;
+    }
+
     fileURL_ = nil;
-    return filePath;
+
+    return {fileSizeBytesMb, fileDuration};
   }
 }
 
@@ -76,66 +110,63 @@ bool IOSAudioFileWriter::writeAudioData(const AudioBufferList *audioBufferList,
     return false;
   }
 
-  // TODO: not sure if this is necessary
   @autoreleasepool {
     NSError *error = nil;
-    AVAudioFormat *filePCMFormat = [audioFile_ processingFormat];
+    AVAudioFormat *fileFormat = [audioFile_ processingFormat];
 
-    if (audioBufferList->mNumberBuffers != filePCMFormat.channelCount ||
-        bufferFormat_.sampleRate != filePCMFormat.sampleRate ||
-        bufferFormat_.interleaved != filePCMFormat.interleaved) {
-      int outputFrameCount = ceil(numFrames * filePCMFormat.sampleRate / bufferFormat_.sampleRate);
+    if (bufferFormat_.sampleRate == fileFormat.sampleRate && bufferFormat_.channelCount == fileFormat.channelCount &&
+        bufferFormat_.isInterleaved == fileFormat.isInterleaved) {
+      AVAudioPCMBuffer *processingBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:fileFormat
+                                                                      bufferListNoCopy:audioBufferList
+                                                                           deallocator:NULL];
+      processingBuffer.frameLength = (AVAudioFrameCount)numFrames;
 
-      AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat_
-                                                                    frameCapacity:(AVAudioFrameCount)numFrames];
+      [audioFile_ writeFromBuffer:processingBuffer error:&error];
 
-      for (int i = 0; i < bufferFormat_.channelCount; i++) {
-        memcpy(
-            inputBuffer.mutableAudioBufferList->mBuffers[i].mData,
-            audioBufferList->mBuffers[i].mData,
-            audioBufferList->mBuffers[i].mDataByteSize);
+      if (error != nil) {
+        NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
+        return false;
       }
 
-      inputBuffer.frameLength = numFrames;
-      AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:filePCMFormat
-                                                                     frameCapacity:outputFrameCount];
-      outputBuffer.frameLength = outputFrameCount;
+      framesWritten_.fetch_add(numFrames);
+      return true;
+    }
+
+    size_t outputFrameCount = ceil(numFrames * fileFormat.sampleRate / bufferFormat_.sampleRate);
 
-      AVAudioConverterInputBlock inputBlock =
-          ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
-      {
-        // this line is probably an delusion, but for my sanity lets keep it
-        inNumberOfPackets = numFrames;
-        *outStatus = AVAudioConverterInputStatus_HaveData;
-        return inputBuffer;
-      };
+    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+      memcpy(
+          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mDataByteSize);
+    }
 
-      [converter_ convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
+    converterInputBuffer_.frameLength = numFrames;
 
-      if (error != nil) {
-        NSLog(@"Error during audio conversion: %@", [error debugDescription]);
-        return false;
-      }
+    AVAudioConverterInputBlock inputBlock =
+        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      // this line is probably an delusion, but for my sanity lets keep it
+      inNumberOfPackets = numFrames;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
 
-      [audioFile_ writeFromBuffer:outputBuffer error:&error];
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
 
-      if (error != nil) {
-        NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
-        return false;
-      }
-    } else {
-      AVAudioPCMBuffer *processingBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:filePCMFormat
-                                                                      bufferListNoCopy:audioBufferList
-                                                                           deallocator:NULL];
+    if (error != nil) {
+      NSLog(@"Error during audio conversion: %@", [error debugDescription]);
+      return false;
+    }
 
-      [audioFile_ writeFromBuffer:processingBuffer error:&error];
+    [audioFile_ writeFromBuffer:converterOutputBuffer_ error:&error];
 
-      if (error != nil) {
-        NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
-        return false;
-      }
+    if (error != nil) {
+      NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
+      return false;
     }
 
+    framesWritten_.fetch_add(numFrames);
     return true;
   }
 }
@@ -184,4 +215,9 @@ NSURL *IOSAudioFileWriter::getFileURL()
   return [dirURL URLByAppendingPathComponent:fileName];
 }
 
+double IOSAudioFileWriter::getCurrentDuration() const
+{
+  return static_cast<double>(framesWritten_.load()) / bufferFormat_.sampleRate;
+}
+
 } // namespace audioapi

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

@@ -16,6 +16,7 @@ namespace audioapi {
 class AudioBus;
 class CircularAudioArray;
 class IOSAudioFileWriter;
+class IOSRecorderCallback;
 class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
@@ -23,8 +24,8 @@ class IOSAudioRecorder : public AudioRecorder {
   IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~IOSAudioRecorder() override;
 
-  void start() override;
-  std::string stop() 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;
@@ -33,8 +34,16 @@ class IOSAudioRecorder : public AudioRecorder {
   void pause() override;
   void resume() override;
 
+  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
+
+  double getCurrentDuration() const override;
+
  private:
   std::shared_ptr<IOSAudioFileWriter> fileWriter_;
+  std::shared_ptr<IOSRecorderCallback> callback_;
+  std::string filePath_{""};
   NativeAudioRecorder *nativeRecorder_;
 };
 

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

@@ -7,6 +7,7 @@
 #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>
@@ -14,22 +15,6 @@
 
 namespace audioapi {
 
-// AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-//   if (isRunning_.load()) {
-//     auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-//     writeToBuffers(inputChannel, 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_);
-//   }
-// };
-
 IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
     : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
 {
@@ -37,6 +22,10 @@ IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegist
     if (usesFileOutput()) {
       fileWriter_->writeAudioData(inputBuffer, numFrames);
     }
+
+    if (usesCallback()) {
+      callback_->receiveAudioData(inputBuffer, numFrames);
+    }
   };
 
   nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
@@ -47,19 +36,20 @@ IOSAudioRecorder::~IOSAudioRecorder()
   stop();
   [nativeRecorder_ cleanup];
 }
-
-void IOSAudioRecorder::start()
+std::string IOSAudioRecorder::start()
 {
+  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
+
   if (isRecording()) {
-    return;
+    return filePath_;
   }
 
   if (usesFileOutput()) {
-    fileWriter_->openFile([nativeRecorder_ getInputFormat]);
+    filePath_ = fileWriter_->openFile([nativeRecorder_ getInputFormat], maxInputBufferLength);
   }
 
   if (usesCallback()) {
-    // TODO: create circular buffer and converter?
+    callback_->prepare([nativeRecorder_ getInputFormat], maxInputBufferLength);
   }
 
   if (isConnected()) {
@@ -67,25 +57,36 @@ void IOSAudioRecorder::start()
   }
 
   [nativeRecorder_ start];
-  isRunning_.store(true);
+  state_.store(RecorderState::Recording);
+
+  return filePath_;
 }
 
-std::string IOSAudioRecorder::stop()
+std::tuple<std::string, double, double> IOSAudioRecorder::stop()
 {
+  std::string filePath = filePath_;
+  double outputFileSize = 0;
+  double outputDuration = 0;
+
   if (!isRecording()) {
-    return std::string("");
+    return {filePath, 0, 0};
   }
 
   [nativeRecorder_ stop];
-  isRunning_.store(false);
-
-  // TODO: send remaining data?
+  state_.store(RecorderState::Idle);
 
   if (usesFileOutput()) {
-    return fileWriter_->closeFile();
+    auto [size, duration] = fileWriter_->closeFile();
+    outputFileSize = size;
+    outputDuration = duration;
   }
 
-  return std::string("");
+  if (usesCallback()) {
+    callback_->cleanup();
+  }
+
+  filePath_ = "";
+  return {filePath, outputFileSize, outputDuration};
 }
 
 void IOSAudioRecorder::enableFileOutput(
@@ -105,8 +106,52 @@ void IOSAudioRecorder::disableFileOutput()
   fileWriter_ = nullptr;
 }
 
-void IOSAudioRecorder::pause() {}
+void IOSAudioRecorder::pause()
+{
+  if (!isRecording()) {
+    return;
+  }
+
+  [nativeRecorder_ stop];
+  state_.store(RecorderState::Paused);
+}
+
+void IOSAudioRecorder::resume()
+{
+  if (!isPaused()) {
+    return;
+  }
 
-void IOSAudioRecorder::resume() {}
+  [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();
+  }
+
+  return duration;
+}
 
 } // namespace audioapi

package/ios/audioapi/ios/core/IOSRecorderCallback.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object AVAudioFormat;
+typedef struct objc_object AudioBufferList;
+typedef struct objc_object AVAudioConverter;
+#endif
+
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class IOSRecorderCallback {
+ public:
+  IOSRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      size_t channelCount,
+      uint64_t callbackId);
+  ~IOSRecorderCallback();
+
+  void prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  void cleanup();
+
+  void receiveAudioData(const AudioBufferList *audioBufferList, int numFrames);
+  void emitAudioData();
+
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+  void sendRemainingData();
+
+ private:
+  float sampleRate_;
+  size_t bufferLength_;
+  size_t channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+  size_t converterInputBufferSize_;
+  size_t converterOutputBufferSize_;
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+
+  AVAudioFormat *bufferFormat_;
+  AVAudioFormat *callbackFormat_;
+  AVAudioConverter *converter_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+};
+
+} // namespace audioapi

package/ios/audioapi/ios/core/IOSRecorderCallback.mm

@@ -0,0 +1,189 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/ios/core/IOSRecorderCallback.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+#include <algorithm>
+
+namespace audioapi {
+
+IOSRecorderCallback::IOSRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry),
+      sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId)
+{
+  ringBufferSize_ = std::max((int)bufferLength_ * 2, 8192);
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto busAudioArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
+    circularBus_[i] = busAudioArray;
+  }
+}
+
+IOSRecorderCallback::~IOSRecorderCallback()
+{
+  @autoreleasepool {
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      circularBus_[i].reset();
+    }
+  }
+}
+
+void IOSRecorderCallback::prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    bufferFormat_ = bufferFormat;
+    converterInputBufferSize_ = maxInputBufferLength;
+
+    converterOutputBufferSize_ =
+        std::max((double)maxInputBufferLength, sampleRate_ / bufferFormat.sampleRate * maxInputBufferLength);
+
+    callbackFormat_ = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                       sampleRate:sampleRate_
+                                                         channels:channelCount_
+                                                      interleaved:NO];
+
+    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat toFormat:callbackFormat_];
+    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    converter_.sampleRateConverterQuality = AVAudioQualityMax;
+    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    converterInputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat_
+                                                          frameCapacity:(AVAudioFrameCount)converterInputBufferSize_];
+    converterOutputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:callbackFormat_
+                                                           frameCapacity:(AVAudioFrameCount)converterOutputBufferSize_];
+  }
+}
+
+void IOSRecorderCallback::cleanup()
+{
+  @autoreleasepool {
+    sendRemainingData();
+
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      circularBus_[i].reset();
+    }
+  }
+}
+
+void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
+{
+  @autoreleasepool {
+    NSError *error = nil;
+
+    if (bufferFormat_.sampleRate == sampleRate_ && bufferFormat_.channelCount == channelCount_ &&
+        !bufferFormat_.isInterleaved) {
+      // Directly write to circular buffer
+      for (size_t i = 0; i < channelCount_; ++i) {
+        auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[i].mData);
+        circularBus_[i]->push_back(inputChannel, numFrames);
+      }
+
+      emitAudioData();
+      return;
+    }
+
+    size_t outputFrameCount = ceil(numFrames * (sampleRate_ / bufferFormat_.sampleRate));
+
+    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+      memcpy(
+          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+          inputBuffer->mBuffers[i].mData,
+          inputBuffer->mBuffers[i].mDataByteSize);
+    }
+
+    converterInputBuffer_.frameLength = numFrames;
+
+    AVAudioConverterInputBlock inputBlock =
+        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      // this line is probably an delusion, but for my sanity lets keep it
+      inNumberOfPackets = numFrames;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
+
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
+
+    if (error != nil) {
+      NSLog(@"Error during audio conversion: %@", [error debugDescription]);
+      return;
+    }
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      auto *inputChannel = static_cast<float *>(converterOutputBuffer_.audioBufferList->mBuffers[i].mData);
+      circularBus_[i]->push_back(inputChannel, outputFrameCount);
+    }
+
+    emitAudioData();
+  }
+}
+
+void IOSRecorderCallback::emitAudioData()
+{
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+    auto bus = std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, bufferLength_);
+    }
+
+    invokeCallback(bus, bufferLength_);
+  }
+}
+
+void IOSRecorderCallback::invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames)
+{
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("audioReady", callbackId_, eventPayload);
+  }
+}
+
+void IOSRecorderCallback::sendRemainingData()
+{
+  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
+  auto bus = std::make_shared<AudioBus>(circularBus_[0]->getNumberOfAvailableFrames(), channelCount_, sampleRate_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto *outputChannel = bus->getChannel(i)->getData();
+    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
+  }
+
+  invokeCallback(bus, numberOfFrames);
+}
+
+} // namespace audioapi

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

@@ -7,9 +7,6 @@ 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;
@@ -18,6 +15,8 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 - (AVAudioFormat *)getInputFormat;
 
+- (int)getBufferSize;
+
 - (void)start;
 
 - (void)stop;