react-native-audio-api 0.13.3 → 0.13.4

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

@@ -2,7 +2,8 @@
 #import <AudioEngine.h>
 #import <AudioSessionManager.h>
 #import <Foundation/Foundation.h>
-
+#include <mutex>
+#include <unordered_map>
 #include <vector>
 
 #include <audioapi/core/sources/RecorderAdapterNode.h>
@@ -19,62 +20,26 @@
 
 namespace audioapi {
 
-static inline NSNumber *recorderFormatNumber(id format, NSString *key)
+static double recorderFormatSampleRate(AVAudioFormat *format)
 {
-  if (format == nil) {
-    return nil;
-  }
-
-  if ([format isKindOfClass:[AVAudioFormat class]]) {
-    AVAudioFormat *audioFormat = (AVAudioFormat *)format;
-
-    if ([key isEqualToString:@"sampleRate"]) {
-      return @(audioFormat.sampleRate);
-    }
-
-    if ([key isEqualToString:@"channelCount"]) {
-      return @(audioFormat.channelCount);
-    }
-
-    if ([key isEqualToString:@"interleaved"]) {
-      return @(audioFormat.interleaved);
-    }
-  }
-
-  @try {
-    id value = [format valueForKey:key];
-    return [value isKindOfClass:[NSNumber class]] ? value : nil;
-  } @catch (__unused NSException *exception) {
-    return nil;
-  }
+  return format.sampleRate;
 }
 
-static inline double recorderFormatSampleRate(id format)
+static AVAudioChannelCount recorderFormatChannelCount(AVAudioFormat *format)
 {
-  return [recorderFormatNumber(format, @"sampleRate") doubleValue];
+  return format.channelCount;
 }
 
-static inline AVAudioChannelCount recorderFormatChannelCount(id format)
+static bool hasUsableRecorderFormat(AVAudioFormat *format)
 {
-  return (AVAudioChannelCount)[recorderFormatNumber(format, @"channelCount") unsignedIntegerValue];
+  return format != nil && format.sampleRate > 0 && format.channelCount > 0;
 }
 
-static inline bool recorderFormatInterleaved(id format)
+static std::string describeRecorderFormat(AVAudioFormat *format)
 {
-  return [recorderFormatNumber(format, @"interleaved") boolValue];
-}
-
-static inline bool hasUsableRecorderFormat(id format)
-{
-  return format != nil && recorderFormatSampleRate(format) > 0 &&
-      recorderFormatChannelCount(format) > 0;
-}
-
-static std::string describeRecorderFormat(id format)
-{
-  return "engineFormat={sampleRate=" + std::to_string(recorderFormatSampleRate(format)) +
-      ", channelCount=" + std::to_string(recorderFormatChannelCount(format)) +
-      ", interleaved=" + std::string(recorderFormatInterleaved(format) ? "true" : "false") + "}";
+  return "engineFormat={sampleRate=" + std::to_string(format.sampleRate) +
+      ", channelCount=" + std::to_string(format.channelCount) +
+      ", interleaved=" + (format.interleaved ? "true" : "false") + "}";
 }
 
 /// @brief Appends the shared input diagnostics (and, on the simulator, the host-mic hint)
@@ -103,31 +68,180 @@ IOSAudioRecorder::IOSAudioRecorder(
     : AudioRecorder(audioEventHandlerRegistry)
 {
   AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (usesFileOutput()) {
-      if (auto lock = Locker::tryLock(fileWriterMutex_)) {
-        fileWriter_->writeAudioData(inputBuffer, numFrames);
-      }
+    runSideEffects(inputBuffer, numFrames);
+  };
+
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
+
+  nativeRecorder_.onInputConfigurationChange = ^{ this->handleInputConfigurationChange(); };
+}
+
+void IOSAudioRecorder::runSideEffects(const AudioBufferList *inputBuffer, int numFrames)
+{
+  if (usesFileOutput()) {
+    if (auto lock = Locker::tryLock(fileWriterMutex_)) {
+      fileWriter_->writeAudioData(inputBuffer, numFrames);
     }
+  }
 
-    if (usesCallback()) {
-      if (auto lock = Locker::tryLock(callbackMutex_)) {
-        std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
-            ->receiveAudioData(inputBuffer, numFrames);
+  if (usesCallback()) {
+    if (auto lock = Locker::tryLock(callbackMutex_)) {
+      std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+          ->receiveAudioData(inputBuffer, numFrames);
+    }
+  }
+
+  if (isConnected()) {
+    if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
+      for (size_t channel = 0; channel < adapterNode_->getChannelCount(); ++channel) {
+        auto *data = static_cast<float *>(inputBuffer->mBuffers[channel].mData);
+        adapterNode_->buff_[channel]->write(data, numFrames);
       }
     }
+  }
+}
 
-    if (isConnected()) {
-      if (auto lock = Locker::tryLock(adapterNodeMutex_)) {
-        for (size_t channel = 0; channel < adapterNode_->getChannelCount(); ++channel) {
-          auto data = (float *)inputBuffer->mBuffers[channel].mData;
+void IOSAudioRecorder::handleInputConfigurationChange()
+{
+  if (isIdle()) {
+    return;
+  }
+
+  BOOL formatChanged = NO;
+  if (![nativeRecorder_ refreshResolvedInputFormatReturningChanged:&formatChanged]) {
+    return;
+  }
+
+  if (!formatChanged) {
+    if (state_.load(std::memory_order_acquire) == RecorderState::Recording) {
+      [nativeRecorder_ setInputArmed:true];
+    }
+    return;
+  }
+
+  reprepareForLiveInput();
+}
+
+Result<NoneType, std::string> IOSAudioRecorder::reprepareForLiveInput()
+{
+  if (isIdle()) {
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  // those values are resolved earlier with actual correct values
+  AVAudioFormat *inputFormat = [nativeRecorder_ getResolvedInputFormat];
+  int maxInputBufferLength = [nativeRecorder_ getResolvedBufferSize];
 
-          adapterNode_->buff_[channel]->write(data, numFrames);
-        }
+  if (!hasUsableRecorderFormat(inputFormat) || maxInputBufferLength <= 0) {
+    return Result<NoneType, std::string>::Err("Recorder input format is unavailable");
+  }
+
+  const bool shouldArmInput = state_.load(std::memory_order_acquire) == RecorderState::Recording;
+  [nativeRecorder_ setInputArmed:false];
+
+  if (usesFileOutput()) {
+    auto fileResult = reprepareFileWriter(inputFormat, maxInputBufferLength);
+    if (fileResult.is_err()) {
+      if (shouldArmInput) {
+        [nativeRecorder_ setInputArmed:true];
       }
+      return fileResult;
     }
-  };
+  }
 
-  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
+  if (usesCallback()) {
+    auto callbackResult = reprepareCallback(inputFormat, maxInputBufferLength);
+    if (callbackResult.is_err()) {
+      if (shouldArmInput) {
+        [nativeRecorder_ setInputArmed:true];
+      }
+      return callbackResult;
+    }
+  }
+
+  if (isConnected() && adapterNode_ != nullptr) {
+    reprepareAdapter(inputFormat, maxInputBufferLength);
+  }
+
+  if (shouldArmInput) {
+    [nativeRecorder_ setInputArmed:true];
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+Result<NoneType, std::string> IOSAudioRecorder::reprepareFileWriter(
+    AVAudioFormat *inputFormat,
+    int maxInputBufferLength)
+{
+  std::scoped_lock lock(fileWriterMutex_);
+
+  if (fileWriter_ == nullptr) {
+    return Result<NoneType, std::string>::Err("File writer is unavailable");
+  }
+
+  if (auto rotatingWriter = std::dynamic_pointer_cast<IOSRotatingFileWriter>(fileWriter_)) {
+    auto result = rotatingWriter->reprepareStreamFormat(
+        inputFormat, static_cast<size_t>(maxInputBufferLength));
+    if (result.is_err()) {
+      fileOutputConfigured_.store(false, std::memory_order_release);
+      return Result<NoneType, std::string>::Err(
+          "Failed to reopen file for writing: " + result.unwrap_err());
+    }
+
+    filePath_ = result.unwrap();
+    fileOutputConfigured_.store(true, std::memory_order_release);
+    return Result<NoneType, std::string>::Ok(None);
+  }
+
+  auto iosWriter = std::static_pointer_cast<IOSFileWriter>(fileWriter_);
+  auto result =
+      iosWriter->reopenForInputFormatChange(inputFormat, static_cast<size_t>(maxInputBufferLength));
+  if (result.is_err()) {
+    fileOutputConfigured_.store(false, std::memory_order_release);
+    return Result<NoneType, std::string>::Err(
+        "Failed to reopen file for writing: " + result.unwrap_err());
+  }
+
+  filePath_ = result.unwrap();
+  recordingSegmentPaths_.push_back(filePath_);
+  fileOutputConfigured_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+Result<NoneType, std::string> IOSAudioRecorder::reprepareCallback(
+    AVAudioFormat *inputFormat,
+    int maxInputBufferLength)
+{
+  std::scoped_lock lock(callbackMutex_);
+
+  if (dataCallback_ == nullptr) {
+    return Result<NoneType, std::string>::Err("Callback is unavailable");
+  }
+
+  auto result = std::static_pointer_cast<IOSRecorderCallback>(dataCallback_)
+                    ->prepare(inputFormat, static_cast<size_t>(maxInputBufferLength));
+  if (result.is_err()) {
+    callbackOutputConfigured_.store(false, std::memory_order_release);
+    return Result<NoneType, std::string>::Err("Failed to prepare callback: " + result.unwrap_err());
+  }
+
+  callbackOutputConfigured_.store(true, std::memory_order_release);
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+void IOSAudioRecorder::reprepareAdapter(AVAudioFormat *inputFormat, int maxInputBufferLength)
+{
+  std::scoped_lock lock(adapterNodeMutex_);
+  if (adapterNode_ == nullptr) {
+    return;
+  }
+
+  adapterNode_->init(
+      static_cast<size_t>(maxInputBufferLength),
+      recorderFormatChannelCount(inputFormat),
+      recorderFormatSampleRate(inputFormat));
+  connectedConfigured_.store(true, std::memory_order_release);
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
@@ -136,6 +250,8 @@ IOSAudioRecorder::~IOSAudioRecorder()
     stop();
   }
 
+  nativeRecorder_.onInputConfigurationChange = nil;
+
   {
     std::scoped_lock lock(callbackMutex_, fileWriterMutex_, adapterNodeMutex_);
     callbackOutputConfigured_.store(false, std::memory_order_release);

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

@@ -12,12 +12,14 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 @property (nonatomic, strong) AVAudioFormat *resolvedInputFormat;
 @property (nonatomic, assign) int resolvedBufferSize;
 @property (atomic, assign) BOOL inputArmed;
+@property (nonatomic, copy) void (^onInputConfigurationChange)(void);
 
 - (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
 
 - (int)getBufferSize;
 - (AVAudioFormat *)getResolvedInputFormat;
 - (int)getResolvedBufferSize;
+- (BOOL)refreshResolvedInputFormatReturningChanged:(BOOL *)formatChanged;
 - (BOOL)start:(NSError **)error;
 
 - (void)stop;

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

@@ -57,17 +57,15 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
 
 - (int)getBufferSize
 {
-  // NOTE: this method should be called only after the session is activated
   AVAudioSession *audioSession = [AVAudioSession sharedInstance];
+  double sampleRate = audioSession.sampleRate;
 
-  // TMPfix: it seems that buffer duration in some cases (background/device change) can switch
-  // to longer values, exceeding buffer size predicted after session start
-  // since it is just a couple of buffers we can set min value of 200ms
-  // to enforce we always have enough frames allocated to pass further down the pipeline
-  float bufferDuration = MAX(audioSession.IOBufferDuration, 0.2);
+  if (self.resolvedInputFormat != nil && self.resolvedInputFormat.sampleRate > 0) {
+    sampleRate = self.resolvedInputFormat.sampleRate;
+  }
 
-  // IOS returns buffer duration rounded, but expects the buffer size to be power of two in runtime
-  return nextPowerOfTwo(ceil(bufferDuration * audioSession.sampleRate));
+  float bufferDuration = MAX(audioSession.IOBufferDuration, 0.2);
+  return nextPowerOfTwo(ceil(bufferDuration * sampleRate));
 }
 
 - (int)getResolvedBufferSize
@@ -75,6 +73,29 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   return self.resolvedBufferSize;
 }
 
+- (BOOL)refreshResolvedInputFormatReturningChanged:(BOOL *)formatChanged
+{
+  AVAudioFormat *liveFormat = [self readLiveInputFormat];
+
+  if (liveFormat == nil || liveFormat.sampleRate <= 0 || liveFormat.channelCount == 0) {
+    return NO;
+  }
+
+  AVAudioFormat *previousFormat = self.resolvedInputFormat;
+  BOOL changed = previousFormat == nil || previousFormat.sampleRate != liveFormat.sampleRate ||
+      previousFormat.channelCount != liveFormat.channelCount ||
+      previousFormat.isInterleaved != liveFormat.isInterleaved;
+
+  self.resolvedInputFormat = liveFormat;
+  self.resolvedBufferSize = [self getBufferSize];
+
+  if (formatChanged != nil) {
+    *formatChanged = changed;
+  }
+
+  return YES;
+}
+
 - (BOOL)start:(NSError **)error
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
@@ -93,7 +114,8 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   self.resolvedBufferSize = 0;
 
   [audioEngine stopIfNecessary];
-  [audioEngine attachInputNodeWithReceiverBlock:self.receiverSinkBlock];
+  [audioEngine attachInputNodeWithReceiverBlock:self.receiverSinkBlock
+                     onInputConfigurationChange:self.onInputConfigurationChange];
 
   if (![audioEngine startIfNecessary]) {
     [audioEngine detachInputNode];
@@ -128,8 +150,6 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   self.inputArmed = NO;
   [audioEngine detachInputNode];
   [audioEngine stopIfPossible];
-  // This makes sure that the engine releases the input properly when we no longer need it
-  // (i.e. no more misleading dot)
   [audioEngine restartAudioEngine];
   self.resolvedInputFormat = nil;
   self.resolvedBufferSize = 0;
@@ -150,7 +170,11 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   assert(audioEngine != nil);
 
   if ([audioEngine startIfNecessary]) {
-    self.inputArmed = YES;
+    if (self.onInputConfigurationChange != nil) {
+      self.onInputConfigurationChange();
+    } else {
+      self.inputArmed = YES;
+    }
   }
 }
 
@@ -161,6 +185,7 @@ static inline uint32_t nextPowerOfTwo(uint32_t x)
   self.resolvedBufferSize = 0;
   self.receiverBlock = nil;
   self.receiverSinkBlock = nil;
+  self.onInputConfigurationChange = nil;
 }
 
 @end

package/ios/audioapi/ios/core/utils/IOSFileWriter.h

@@ -41,6 +41,9 @@ class IOSFileWriter : public AudioFileWriter {
       AVAudioFormat *bufferFormat,
       size_t maxInputBufferLength,
       const std::string &fileNameOverride);
+  OpenFileResult reopenForInputFormatChange(
+      AVAudioFormat *bufferFormat,
+      size_t maxInputBufferLength);
   CloseFileResult closeFile() override;
 
   void writeAudioData(const AudioBufferList *audioBufferList, int numFrames) override;

package/ios/audioapi/ios/core/utils/IOSFileWriter.mm

@@ -140,6 +140,23 @@ OpenFileResult IOSFileWriter::openFile(
   }
 }
 
+OpenFileResult IOSFileWriter::reopenForInputFormatChange(
+    AVAudioFormat *bufferFormat,
+    size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    if (isFileOpen()) {
+      auto closeResult = closeFile();
+      if (closeResult.is_err()) {
+        return OpenFileResult::Err(
+            "Failed to finalize recording segment: " + closeResult.unwrap_err());
+      }
+    }
+
+    return openFile(bufferFormat, maxInputBufferLength, "");
+  }
+}
+
 void IOSFileWriter::rollbackFailedOpen()
 {
   offloader_.reset();

package/ios/audioapi/ios/core/utils/IOSRotatingFileWriter.h

@@ -30,6 +30,9 @@ class IOSRotatingFileWriter : public IOSFileWriter, public RotatingFileWriter {
       AVAudioFormat *streamFormat,
       size_t streamMaxBufferSizeInFrames,
       const std::string &fileNameOverride) override;
+  OpenFileResult reprepareStreamFormat(
+      AVAudioFormat *streamFormat,
+      size_t streamMaxBufferSizeInFrames);
   CloseFileResult closeFile() override;
   [[nodiscard]] double getCurrentDuration() const override;
 

package/ios/audioapi/ios/core/utils/IOSRotatingFileWriter.mm

@@ -46,6 +46,27 @@ OpenFileResult IOSRotatingFileWriter::openFile(
   return openInnerWriter();
 }
 
+OpenFileResult IOSRotatingFileWriter::reprepareStreamFormat(
+    AVAudioFormat *streamFormat,
+    size_t streamMaxBufferSizeInFrames)
+{
+  streamFormat_ = streamFormat;
+  streamMaxBufferSizeInFrames_ = streamMaxBufferSizeInFrames;
+
+  if (currentWriter_ == nullptr) {
+    currentWriter_ = writerFactory_(fileProperties_);
+    return openInnerWriter();
+  }
+
+  rotateFiles();
+
+  if (currentWriter_ == nullptr) {
+    return OpenFileResult::Err("Failed to reopen file for writing after input format change");
+  }
+
+  return OpenFileResult::Ok(currentWriter_->getFilePath());
+}
+
 void IOSRotatingFileWriter::writeAudioData(AudioDataType data, int numFrames)
 {
   if (currentWriter_ == nullptr) {

package/ios/audioapi/ios/system/AudioEngine.h

@@ -33,7 +33,8 @@ typedef NS_ENUM(NSInteger, AudioEngineState) {
                                  channelCount:(AVAudioChannelCount)channelCount;
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
 
-- (void)attachInputNodeWithReceiverBlock:(AVAudioSinkNodeReceiverBlock)receiverBlock;
+- (void)attachInputNodeWithReceiverBlock:(AVAudioSinkNodeReceiverBlock)receiverBlock
+              onInputConfigurationChange:(void (^)(void))onInputConfigurationChange;
 - (void)detachInputNode;
 - (AVAudioFormat *)getLiveInputFormat;
 

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

@@ -17,6 +17,7 @@
 @interface AudioEngineInputRegistration : NSObject
 
 @property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverBlock;
+@property (nonatomic, copy) void (^onInputConfigurationChange)(void);
 
 @end
 
@@ -24,7 +25,7 @@
 @end
 
 @interface AudioEngine () {
-  std::mutex _engineLock;
+  std::recursive_mutex _engineLock;
   BOOL _isRebuildingAudioEngine;
 }
 
@@ -43,6 +44,7 @@
 - (AVAudioFormat *)liveInputFormat;
 - (void)resetInputNode;
 - (void)rebuildAudioEngineAndResumeIfNeeded;
+- (void)notifyConfigurationChanges;
 
 @end
 
@@ -161,6 +163,29 @@ static AudioEngine *_sharedInstance = nil;
   [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
 }
 
+- (AVAudioFormat *)liveInputFormat
+{
+  std::scoped_lock lock(_engineLock);
+
+  if (self.audioEngine == nil) {
+    return nil;
+  }
+
+  AVAudioInputNode *engineInputNode = self.audioEngine.inputNode;
+
+  if (engineInputNode == nil) {
+    return nil;
+  }
+
+  AVAudioFormat *inputFormat = [engineInputNode outputFormatForBus:0];
+
+  if (inputFormat == nil || inputFormat.sampleRate <= 0 || inputFormat.channelCount == 0) {
+    return nil;
+  }
+
+  return inputFormat;
+}
+
 - (AVAudioFormat *)currentInputConnectionFormat
 {
   AVAudioFormat *inputFormat = [self liveInputFormat];
@@ -186,6 +211,14 @@ static AudioEngine *_sharedInstance = nil;
     return YES;
   }
 
+  NSError *sessionError = nil;
+  if (![self.sessionManager ensureActive:true error:&sessionError]) {
+    NSLog(
+        @"Error while activating audio session before input materialization: %@",
+        [sessionError debugDescription]);
+    return NO;
+  }
+
   AVAudioFormat *inputFormat = [self currentInputConnectionFormat];
 
   if (inputFormat == nil) {
@@ -253,6 +286,7 @@ static AudioEngine *_sharedInstance = nil;
 }
 
 - (void)attachInputNodeWithReceiverBlock:(AVAudioSinkNodeReceiverBlock)receiverBlock
+              onInputConfigurationChange:(void (^)(void))onInputConfigurationChange
 {
   std::scoped_lock lock(_engineLock);
   [self createAudioEngineIfNeeded];
@@ -263,6 +297,7 @@ static AudioEngine *_sharedInstance = nil;
 
   AudioEngineInputRegistration *registration = [[AudioEngineInputRegistration alloc] init];
   registration.receiverBlock = receiverBlock;
+  registration.onInputConfigurationChange = onInputConfigurationChange;
   self.inputRegistration = registration;
 
   [self materializeInputNodeIfNeeded];
@@ -292,30 +327,8 @@ static AudioEngine *_sharedInstance = nil;
   [self resetInputNode];
 }
 
-- (AVAudioFormat *)liveInputFormat
-{
-  if (self.audioEngine == nil) {
-    return nil;
-  }
-
-  AVAudioInputNode *engineInputNode = self.audioEngine.inputNode;
-
-  if (engineInputNode == nil) {
-    return nil;
-  }
-
-  AVAudioFormat *inputFormat = [engineInputNode outputFormatForBus:0];
-
-  if (inputFormat == nil || inputFormat.sampleRate <= 0 || inputFormat.channelCount == 0) {
-    return nil;
-  }
-
-  return inputFormat;
-}
-
 - (AVAudioFormat *)getLiveInputFormat
 {
-  std::scoped_lock lock(_engineLock);
   return [self liveInputFormat];
 }
 
@@ -377,6 +390,7 @@ static AudioEngine *_sharedInstance = nil;
 
   if (!shouldResume) {
     self.state = AudioEngineState::AudioEngineStatePaused;
+    [self notifyConfigurationChanges];
     return;
   }
 
@@ -388,11 +402,20 @@ static AudioEngine *_sharedInstance = nil;
         @"Error while restarting the audio engine after interruption: %@",
         [error debugDescription]);
     self.state = AudioEngineState::AudioEngineStateIdle;
+    [self notifyConfigurationChanges];
     return;
   }
 
   self.state = AudioEngineState::AudioEngineStateRunning;
   self.sessionDeactivationInvalidatedGraph = false;
+  [self notifyConfigurationChanges];
+}
+
+- (void)notifyConfigurationChanges
+{
+  if (self.inputRegistration != nil && self.inputRegistration.onInputConfigurationChange != nil) {
+    self.inputRegistration.onInputConfigurationChange();
+  }
 }
 
 - (AudioEngineState)getState
@@ -426,6 +449,8 @@ static AudioEngine *_sharedInstance = nil;
     [self startEngine];
   }
 
+  [self notifyConfigurationChanges];
+
   _isRebuildingAudioEngine = NO;
 }
 
@@ -497,6 +522,7 @@ static AudioEngine *_sharedInstance = nil;
   std::scoped_lock lock(_engineLock);
   if (self.state == AudioEngineState::AudioEngineStateRunning && self.audioEngine != nil &&
       [self.audioEngine isRunning]) {
+    [self materializeTrackedNodesIfNeeded];
     return true;
   }
 

package/ios/audioapi/ios/system/SystemNotificationManager.mm

@@ -218,6 +218,16 @@ static NSString *NotificationManagerContext = @"SystemNotificationManagerContext
       invokeHandlerWithEventName:audioapi::AudioEvent::ROUTE_CHANGE
                          payload:audioapi::StringPayload{
                                      .name = "reason", .reason = [reasonStr UTF8String]}];
+
+  switch (routeChangeReason) {
+    case AVAudioSessionRouteChangeReasonNewDeviceAvailable:
+    case AVAudioSessionRouteChangeReasonOldDeviceUnavailable:
+    case AVAudioSessionRouteChangeReasonRouteConfigurationChange:
+      [self handleEngineConfigurationChange:nil];
+      break;
+    default:
+      break;
+  }
 }
 
 - (void)handleMediaServicesReset:(NSNotification *)notification