react-native-audio-api 0.10.0-nightly-c815c40-20251027 → 0.11.0-alpha.0

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

@@ -0,0 +1,187 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/IOSAudioFileOptions.h>
+#include <audioapi/ios/core/IOSAudioFileWriter.h>
+
+namespace audioapi {
+IOSAudioFileWriter::IOSAudioFileWriter(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags)
+{
+  fileOptions_ = std::make_shared<IOSAudioFileOptions>(sampleRate, channelCount, bitRate, iosFlags);
+}
+
+IOSAudioFileWriter::~IOSAudioFileWriter()
+{
+  fileURL_ = nil;
+  audioFile_ = nil;
+  converter_ = nil;
+  bufferFormat_ = nil;
+}
+
+void IOSAudioFileWriter::openFile(AVAudioFormat *bufferFormat)
+{
+  @autoreleasepool {
+    if (audioFile_ != nil) {
+      NSLog(@"⚠️ createFileForWriting: currentAudioFile_ already exists");
+      return;
+    }
+
+    bufferFormat_ = bufferFormat;
+
+    NSError *error = nil;
+    NSDictionary *settings = fileOptions_->getFileSettings();
+    fileURL_ = getFileURL();
+
+    NSLog(@"ℹ️ Creating audio file at URL: %@", [fileURL_ absoluteString]);
+
+    audioFile_ = [[AVAudioFile alloc] initForWriting:fileURL_
+                                            settings:settings
+                                        commonFormat:AVAudioPCMFormatFloat32
+                                         interleaved:bufferFormat.interleaved
+                                               error:&error];
+    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat toFormat:[audioFile_ processingFormat]];
+    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    converter_.sampleRateConverterQuality = AVAudioQualityMax;
+    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    NSLog(@"buferFormat: %@ fileFormat: %@", bufferFormat, [audioFile_ processingFormat]);
+
+    if (error != nil || audioFile_ == nil) {
+      NSLog(@"Error creating audio file for writing: %@", [error debugDescription]);
+      audioFile_ = nil;
+    }
+  }
+}
+
+std::string IOSAudioFileWriter::closeFile()
+{
+  @autoreleasepool {
+    std::string filePath = [[fileURL_ path] UTF8String];
+
+    if (audioFile_ == nil) {
+      return "";
+    }
+
+    // AVAudioFile automatically finalizes the file when deallocated
+    audioFile_ = nil;
+    fileURL_ = nil;
+    return filePath;
+  }
+}
+
+bool IOSAudioFileWriter::writeAudioData(const AudioBufferList *audioBufferList, int numFrames)
+{
+  if (audioFile_ == nil) {
+    NSLog(@"⚠️ writeAudioData: audioFile is nil, cannot write data");
+    return false;
+  }
+
+  // TODO: not sure if this is necessary
+  @autoreleasepool {
+    NSError *error = nil;
+    AVAudioFormat *filePCMFormat = [audioFile_ processingFormat];
+
+    if (audioBufferList->mNumberBuffers != filePCMFormat.channelCount ||
+        bufferFormat_.sampleRate != filePCMFormat.sampleRate ||
+        bufferFormat_.interleaved != filePCMFormat.interleaved) {
+      int outputFrameCount = ceil(numFrames * filePCMFormat.sampleRate / bufferFormat_.sampleRate);
+
+      AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat_
+                                                                    frameCapacity:(AVAudioFrameCount)numFrames];
+
+      for (int i = 0; i < bufferFormat_.channelCount; i++) {
+        memcpy(
+            inputBuffer.mutableAudioBufferList->mBuffers[i].mData,
+            audioBufferList->mBuffers[i].mData,
+            audioBufferList->mBuffers[i].mDataByteSize);
+      }
+
+      inputBuffer.frameLength = numFrames;
+      AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:filePCMFormat
+                                                                     frameCapacity:outputFrameCount];
+      outputBuffer.frameLength = outputFrameCount;
+
+      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;
+      };
+
+      [converter_ convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
+
+      if (error != nil) {
+        NSLog(@"Error during audio conversion: %@", [error debugDescription]);
+        return false;
+      }
+
+      [audioFile_ writeFromBuffer:outputBuffer error:&error];
+
+      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];
+
+      [audioFile_ writeFromBuffer:processingBuffer error:&error];
+
+      if (error != nil) {
+        NSLog(@"Error writing audio data to file: %@", [error debugDescription]);
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+NSString *IOSAudioFileWriter::getISODateStringForDirectory()
+{
+  NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
+  fmt.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+  fmt.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"UTC"]; // or local if you prefer
+  fmt.dateFormat = @"yyyy-MM-dd";
+  return [fmt stringFromDate:[NSDate date]];
+}
+
+NSString *IOSAudioFileWriter::getTimestampForFilename()
+{
+  NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
+  fmt.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+  fmt.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"UTC"]; // or local if you prefer
+  fmt.dateFormat = @"yyyyMMdd_HHmmss_SSS";
+  return [fmt stringFromDate:[NSDate date]];
+}
+
+NSURL *IOSAudioFileWriter::getFileURL()
+{
+  NSError *error = nil;
+
+  NSSearchPathDirectory searchDirectory = fileOptions_->getDirectory();
+  NSString *directory = [NSString stringWithFormat:@"AudioAPI/%@", getISODateStringForDirectory()];
+
+  NSURL *baseURL = [[[NSFileManager defaultManager] URLsForDirectory:searchDirectory
+                                                           inDomains:NSUserDomainMask] firstObject];
+  NSURL *dirURL = [baseURL URLByAppendingPathComponent:directory isDirectory:YES];
+
+  [[NSFileManager defaultManager] createDirectoryAtURL:dirURL
+                           withIntermediateDirectories:YES
+                                            attributes:nil
+                                                 error:&error];
+
+  if (error != nil) {
+    NSLog(@"Error creating directory for audio recordings: %@", [error debugDescription]);
+    dirURL = baseURL;
+  }
+
+  NSString *fileName =
+      [NSString stringWithFormat:@"audio_%@.%@", getTimestampForFilename(), fileOptions_->getFileExtension()];
+  return [dirURL URLByAppendingPathComponent:fileName];
+}
+
+} // namespace audioapi

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

@@ -1,8 +1,11 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as Objective-C++
+#ifdef __OBJC__ // when compiled as C++
 #import <NativeAudioRecorder.h>
-#else // when compiled as C++
+#else
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object NSURL;
+typedef struct objc_object AudioBufferList;
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
@@ -12,22 +15,27 @@ namespace audioapi {
 
 class AudioBus;
 class CircularAudioArray;
+class IOSAudioFileWriter;
+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;
+  std::string stop() override;
+
+  void enableFileOutput(float sampleRate, size_t channelCount, size_t bitRate, size_t iosFlags, size_t androidFlags)
+      override;
+  void disableFileOutput() override;
+
+  void pause() override;
+  void resume() override;
 
  private:
-  NativeAudioRecorder *audioRecorder_;
+  std::shared_ptr<IOSAudioFileWriter> fileWriter_;
+  NativeAudioRecorder *nativeRecorder_;
 };
 
 } // namespace audioapi

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

@@ -1,70 +1,112 @@
 #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/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(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
-{
-  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (isRunning_.load()) {
-      auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-      writeToBuffers(inputChannel, numFrames);
-    }
+// 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();
 
-    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-      auto *outputChannel = bus->getChannel(0)->getData();
+//     circularBuffer_->pop_front(outputChannel, bufferLength_);
 
-      circularBuffer_->pop_front(outputChannel, bufferLength_);
+//     invokeOnAudioReadyCallback(bus, bufferLength_);
+//   }
+// };
 
-      invokeOnAudioReadyCallback(bus, bufferLength_);
+IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
+{
+  AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+    if (usesFileOutput()) {
+      fileWriter_->writeAudioData(inputBuffer, numFrames);
     }
   };
 
-  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
-                                                         bufferLength:bufferLength
-                                                           sampleRate:sampleRate];
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [audioRecorder_ cleanup];
+  [nativeRecorder_ cleanup];
 }
 
 void IOSAudioRecorder::start()
 {
-  if (isRunning_.load()) {
+  if (isRecording()) {
     return;
   }
 
-  [audioRecorder_ start];
+  if (usesFileOutput()) {
+    fileWriter_->openFile([nativeRecorder_ getInputFormat]);
+  }
+
+  if (usesCallback()) {
+    // TODO: create circular buffer and converter?
+  }
+
+  if (isConnected()) {
+    // TODO: set adapter node properties?
+  }
+
+  [nativeRecorder_ start];
   isRunning_.store(true);
 }
 
-void IOSAudioRecorder::stop()
+std::string IOSAudioRecorder::stop()
 {
-  if (!isRunning_.load()) {
-    return;
+  if (!isRecording()) {
+    return std::string("");
   }
 
+  [nativeRecorder_ stop];
   isRunning_.store(false);
-  [audioRecorder_ stop];
 
-  sendRemainingData();
+  // TODO: send remaining data?
+
+  if (usesFileOutput()) {
+    return fileWriter_->closeFile();
+  }
+
+  return std::string("");
 }
 
+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() {}
+
+void IOSAudioRecorder::resume() {}
+
 } // namespace audioapi

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

@@ -14,13 +14,9 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 @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;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate;
+- (AVAudioFormat *)getInputFormat;
 
 - (void)start;
 

package/ios/audioapi/ios/core/NativeAudioRecorder.m

@@ -5,40 +5,18 @@
 @implementation NativeAudioRecorder
 
 - (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate
 {
   if (self = [super init]) {
-    self.bufferLength = bufferLength;
-    self.sampleRate = sampleRate;
-
     self.receiverBlock = [receiverBlock copy];
 
-    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
-
-    if (!devicePrefferedSampleRate) {
-      NSError *error;
-      devicePrefferedSampleRate = sampleRate;
-
-      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
-    }
-
-    self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                        sampleRate:devicePrefferedSampleRate
-                                                          channels:1
-                                                       interleaved:NO];
-    self.outputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                         sampleRate:sampleRate
-                                                           channels:1
-                                                        interleaved:NO];
-    self.audioConverter = [[AVAudioConverter alloc] initFromFormat:self.inputFormat toFormat:self.outputFormat];
-
     __weak typeof(self) weakSelf = self;
     self.receiverSinkBlock = ^OSStatus(
         const AudioTimeStamp *_Nonnull timestamp,
         AVAudioFrameCount frameCount,
         const AudioBufferList *_Nonnull inputData) {
-      return [weakSelf processAudioInput:inputData withFrameCount:frameCount atTimestamp:timestamp];
+      weakSelf.receiverBlock(inputData, frameCount);
+
+      return kAudioServicesNoError;
     };
 
     self.sinkNode = [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
@@ -47,55 +25,9 @@
   return self;
 }
 
-- (OSStatus)processAudioInput:(const AudioBufferList *)inputData
-               withFrameCount:(AVAudioFrameCount)frameCount
-                  atTimestamp:(const AudioTimeStamp *)timestamp
+- (AVAudioFormat *)getInputFormat
 {
-  float inputSampleRate = self.inputFormat.sampleRate;
-  float outputSampleRate = self.outputFormat.sampleRate;
-
-  if (inputSampleRate != outputSampleRate) {
-    AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
-                                                                  frameCapacity:frameCount];
-    memcpy(
-        inputBuffer.mutableAudioBufferList->mBuffers[0].mData,
-        inputData->mBuffers[0].mData,
-        inputData->mBuffers[0].mDataByteSize);
-    inputBuffer.frameLength = frameCount;
-
-    int outputFrameCount = frameCount * outputSampleRate / inputSampleRate;
-
-    AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.audioConverter.outputFormat
-                                                                   frameCapacity:outputFrameCount];
-
-    NSError *error = nil;
-    AVAudioConverterInputBlock inputBlock =
-        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
-    {
-      *outStatus = AVAudioConverterInputStatus_HaveData;
-      return inputBuffer;
-    };
-
-    /// IMPORTANT: AVAudioConverter leaks memory without autorelease pool
-    /// more details here: https://github.com/poneciak57/AVAudioConverter-memory-leak-repro-electric-boogaloo
-    /// we can try to remove it in the future or refactor to reuse buffers to minimize allocations
-    @autoreleasepool {
-      [self.audioConverter convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
-    }
-
-    if (error) {
-      NSLog(@"Error during audio conversion: %@", error.localizedDescription);
-      return kAudioServicesBadSpecifierSizeError;
-    }
-
-    self.receiverBlock(outputBuffer.audioBufferList, outputBuffer.frameLength);
-
-    return kAudioServicesNoError;
-  }
-
-  self.receiverBlock(inputData, frameCount);
-
-  return kAudioServicesNoError;
+  return [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
 }
 
 - (void)start

package/ios/audioapi/ios/system/AudioEngine.mm

@@ -118,9 +118,9 @@ static AudioEngine *_sharedInstance = nil;
 - (void)stopEngine
 {
   NSLog(@"[AudioEngine] stopEngine");
-  if (![self.audioEngine isRunning]) {
-    return;
-  }
+  //  if (![self.audioEngine isRunning]) {
+  //    return;
+  //  }
 
   self.isSupposedToBeRunning = false;
   [self.audioEngine stop];

package/ios/audioapi/ios/system/AudioSessionManager.mm

@@ -213,15 +213,6 @@
 
 - (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
-  // if there is no entry NSMicrophoneUsageDescription calling requestRecordPermission will quit an app
-  if (value == nil) {
-    reject(
-        nil,
-        @"There is no NSMicrophoneUsageDescription entry in info.plist file. App cannot access microphone without it.",
-        nil);
-    return;
-  }
   if (@available(iOS 17, *)) {
     [AVAudioSession.sharedInstance requestRecordPermission:^(BOOL granted) {
       if (granted) {

package/ios/audioapi/ios/system/LockScreenManager.h

@@ -12,6 +12,7 @@
 
 @property (nonatomic, weak) MPNowPlayingInfoCenter *playingInfoCenter;
 @property (nonatomic, copy) NSString *artworkUrl;
+@property (nonatomic, assign) bool isReceivingRemoteCommands;
 
 - (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
 - (void)cleanup;

package/ios/audioapi/ios/system/LockScreenManager.mm

@@ -19,28 +19,40 @@
   if (self = [super init]) {
     self.audioAPIModule = audioAPIModule;
     self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+    self.isReceivingRemoteCommands = false;
+  }
+
+  return self;
+}
 
+- (void)toggleRemoteCommands:(bool)enable
+{
+  if (enable && !self.isReceivingRemoteCommands) {
+    self.isReceivingRemoteCommands = true;
     dispatch_async(dispatch_get_main_queue(), ^{
       [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
     });
+    return;
+  } else if (!enable && self.isReceivingRemoteCommands) {
+    self.isReceivingRemoteCommands = false;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
+    });
+    return;
   }
-
-  return self;
 }
 
 - (void)cleanup
 {
   NSLog(@"[LockScreenManager] cleanup");
+  [self toggleRemoteCommands:false];
   [self resetLockScreenInfo];
-
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
-  });
 }
 
 - (void)setLockScreenInfo:(NSDictionary *)info
 {
   self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+  [self toggleRemoteCommands:true];
 
   // now playing info(lock screen info)
   NSMutableDictionary *lockScreenInfoDict;
@@ -79,6 +91,7 @@
 
 - (void)resetLockScreenInfo
 {
+  [self toggleRemoteCommands:false];
   self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
   self.playingInfoCenter.nowPlayingInfo = nil;
   self.artworkUrl = nil;