react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-52d0b79-20251216

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

@@ -10,29 +10,25 @@ static AudioEngine *_sharedInstance = nil;
   return _sharedInstance;
 }
 
-- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager
+- (instancetype)init
 {
   if (self = [super init]) {
-    self.isInterrupted = false;
-    self.isSupposedToBeRunning = true;
+    self.state = AudioEngineState::AudioEngineStateIdle;
     self.audioEngine = [[AVAudioEngine alloc] init];
     self.inputNode = nil;
 
     self.sourceNodes = [[NSMutableDictionary alloc] init];
     self.sourceFormats = [[NSMutableDictionary alloc] init];
-    self.sourceStates = [[NSMutableDictionary alloc] init];
 
-    self.sessionManager = sessionManager;
+    self.sessionManager = [AudioSessionManager sharedInstance];
   }
 
   _sharedInstance = self;
-
   return self;
 }
 
 - (void)cleanup
 {
-  NSLog(@"[AudioEngine] cleanup");
   if ([self.audioEngine isRunning]) {
     [self.audioEngine stop];
   }
@@ -40,212 +36,229 @@ static AudioEngine *_sharedInstance = nil;
   self.audioEngine = nil;
   self.sourceNodes = nil;
   self.sourceFormats = nil;
-  self.sourceStates = nil;
   self.inputNode = nil;
 
   [self.sessionManager setActive:false];
   self.sessionManager = nil;
 }
 
-- (void)rebuildAudioEngine
+- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format
 {
-  for (id sourceNodeId in self.sourceNodes) {
-    AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
-    AVAudioFormat *format = [self.sourceFormats valueForKey:sourceNodeId];
-
-    [self.audioEngine attachNode:sourceNode];
-    [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
-  }
-
-  if (self.inputNode) {
-    [self.audioEngine attachNode:self.inputNode];
-    [self.audioEngine connect:self.audioEngine.inputNode to:self.inputNode format:nil];
-  }
-}
+  NSString *sourceNodeId = [[NSUUID UUID] UUIDString];
 
-- (bool)rebuildAudioEngineAndStartIfNecessary
-{
-  [self rebuildAudioEngine];
-  return [self startIfNecessary];
-}
+  [self.sourceNodes setValue:sourceNode forKey:sourceNodeId];
+  [self.sourceFormats setValue:format forKey:sourceNodeId];
 
-- (bool)restartAudioEngine
-{
-  if ([self.audioEngine isRunning]) {
-    [self.audioEngine stop];
-  }
+  [self.audioEngine attachNode:sourceNode];
+  [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
 
-  self.audioEngine = [[AVAudioEngine alloc] init];
-  return [self rebuildAudioEngineAndStartIfNecessary];
+  return sourceNodeId;
 }
 
-- (bool)startEngine
+- (void)detachSourceNodeWithId:(NSString *)sourceNodeId
 {
-  NSLog(@"[AudioEngine] startEngine");
-  NSError *error = nil;
-  self.isSupposedToBeRunning = true;
-
-  if ([self.audioEngine isRunning] && ![self isInterrupted]) {
-    NSLog(@"[AudioEngine] Engine is already running");
-    return true;
-  }
+  AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
 
-  if (![self.sessionManager setActive:true]) {
-    return false;
+  if (sourceNode == nil) {
+    NSLog(@"[AudioEngine] No source node found with ID: %@", sourceNodeId);
+    return;
   }
 
-  if ([self isInterrupted]) {
-    NSLog(@"[AudioEngine] rebuilding after interruption");
-    [self.audioEngine stop];
-    [self.audioEngine reset];
+  [self.audioEngine detachNode:sourceNode];
 
-    [self rebuildAudioEngine];
+  [self.sourceNodes removeObjectForKey:sourceNodeId];
+  [self.sourceFormats removeObjectForKey:sourceNodeId];
+}
 
-    self.isInterrupted = false;
-  }
+- (void)attachInputNode:(AVAudioSinkNode *)inputNode
+{
+  self.inputNode = inputNode;
+  AVAudioFormat *format = [self.audioEngine.inputNode inputFormatForBus:0];
 
-  [self.audioEngine prepare];
-  [self.audioEngine startAndReturnError:&error];
+  [self.audioEngine attachNode:inputNode];
+  [self.audioEngine connect:self.audioEngine.inputNode to:inputNode format:format];
+}
 
-  if (error != nil) {
-    NSLog(@"Error while starting the audio engine: %@", [error debugDescription]);
-    return false;
+- (void)detachInputNode
+{
+  if (self.inputNode == nil) {
+    return;
   }
 
-  return true;
+  [self.audioEngine detachNode:self.inputNode];
+  self.inputNode = nil;
 }
 
-- (void)stopEngine
+- (void)onInterruptionBegin
 {
-  NSLog(@"[AudioEngine] stopEngine");
-  if (![self.audioEngine isRunning]) {
+  if (self.state != AudioEngineState::AudioEngineStateRunning) {
+    // If engine was not active, do nothing
     return;
   }
 
-  self.isSupposedToBeRunning = false;
-  [self.audioEngine stop];
+  // If engine was active or paused (or interrupted :)) mark as interrupted
+  self.state = AudioEngineState::AudioEngineStateInterrupted;
 }
 
-- (void)pauseEngine:(NSString *)sourceNodeId
+- (void)onInterruptionEnd:(bool)shouldResume
 {
-  NSLog(@"[AudioEngine] pauseEngine");
-  self.isSupposedToBeRunning = false;
+  NSError *error = nil;
 
-  if (![self.audioEngine isRunning]) {
+  if (self.state != AudioEngineState::AudioEngineStateInterrupted) {
+    // If engine was not interrupted, do nothing
+    // Not a real condition, but better be safe than sorry :shrug:
     return;
   }
 
-  [self.sourceStates setValue:@false forKey:sourceNodeId];
-  [self pauseIfNecessary];
-}
+  // Stop just in case, reset the engine and build it from scratch
+  [self stopIfNecessary];
+  [self.audioEngine reset];
+  [self rebuildAudioEngine];
 
-- (bool)isRunning
-{
-  return [self.audioEngine isRunning] && !self.isInterrupted;
-}
+  // If shouldResume is false, mark the engine as paused and wait
+  // for JS-side resume command
+  // TODO: this should be notified to the user f.e. via Event Emitter
+  if (!shouldResume) {
+    self.state = AudioEngineState::AudioEngineStatePaused;
+    return;
+  }
 
-- (void)markAsInterrupted
-{
-  self.isInterrupted = true;
-  self.isSupposedToBeRunning = false;
+  [self.audioEngine prepare];
+  [self.audioEngine startAndReturnError:&error];
+
+  if (error != nil) {
+    NSLog(
+        @"Error while restarting the audio engine after interruption: %@",
+        [error debugDescription]);
+    self.state = AudioEngineState::AudioEngineStateIdle;
+    return;
+  }
+
+  self.state = AudioEngineState::AudioEngineStateRunning;
 }
 
-- (void)unmarkAsInterrupted
+- (AudioEngineState)getState
 {
-  self.isInterrupted = false;
+  return self.state;
 }
 
-- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format
+/// @brief Rebuilds the audio engine by re-attaching and re-connecting all source nodes and input node.
+- (void)rebuildAudioEngine
 {
-  NSString *sourceNodeId = [[NSUUID UUID] UUIDString];
-  NSLog(@"[AudioEngine] attaching new source node with ID: %@", sourceNodeId);
+  self.audioEngine = [[AVAudioEngine alloc] init];
 
-  [self.sourceNodes setValue:sourceNode forKey:sourceNodeId];
-  [self.sourceFormats setValue:format forKey:sourceNodeId];
-  [self.sourceStates setValue:@true forKey:sourceNodeId];
+  for (id sourceNodeId in self.sourceNodes) {
+    AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
+    AVAudioFormat *format = [self.sourceFormats valueForKey:sourceNodeId];
 
-  [self.audioEngine attachNode:sourceNode];
-  [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
+    [self.audioEngine attachNode:sourceNode];
+    [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
+  }
 
-  return sourceNodeId;
+  if (self.inputNode) {
+    [self.audioEngine attachNode:self.inputNode];
+    [self.audioEngine connect:self.audioEngine.inputNode to:self.inputNode format:nil];
+  }
 }
 
-- (void)detachSourceNodeWithId:(NSString *)sourceNodeId
+// @brief Starts the audio engine if not already running.
+- (bool)startEngine
 {
-  NSLog(@"[AudioEngine] detaching source node with ID: %@", sourceNodeId);
+  NSError *error = nil;
 
-  AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
+  if ([self.audioEngine isRunning] && self.state == AudioEngineState::AudioEngineStateRunning) {
+    return true;
+  }
 
-  if (sourceNode == nil) {
-    NSLog(@"[AudioEngine] No source node found with ID: %@", sourceNodeId);
-    return;
+  if (![self.sessionManager setActive:true]) {
+    return false;
   }
 
-  [self.audioEngine detachNode:sourceNode];
+  if (self.state == AudioEngineState::AudioEngineStateInterrupted) {
+    NSLog(@"[AudioEngine] rebuilding after interruption");
+    [self.audioEngine stop];
+    [self.audioEngine reset];
+    [self rebuildAudioEngine];
+  }
 
-  [self.sourceNodes removeObjectForKey:sourceNodeId];
-  [self.sourceFormats removeObjectForKey:sourceNodeId];
-  [self.sourceStates removeObjectForKey:sourceNodeId];
-}
+  [self.audioEngine prepare];
+  [self.audioEngine startAndReturnError:&error];
 
-- (void)attachInputNode:(AVAudioSinkNode *)inputNode
-{
-  self.inputNode = inputNode;
+  if (error != nil) {
+    NSLog(@"Error while starting the audio engine: %@", [error debugDescription]);
+    return false;
+  }
 
-  [self.audioEngine attachNode:inputNode];
-  [self.audioEngine connect:self.audioEngine.inputNode to:inputNode format:nil];
+  self.state = AudioEngineState::AudioEngineStateRunning;
+  return true;
 }
 
-- (void)detachInputNode
+- (void)stopEngine
 {
-  if (self.inputNode == nil) {
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
     return;
   }
 
-  [self.audioEngine detachNode:self.inputNode];
-  self.inputNode = nil;
-  [self restartAudioEngine];
+  [self.audioEngine stop];
+  self.state = AudioEngineState::AudioEngineStateIdle;
 }
 
 - (bool)startIfNecessary
 {
-  if ([self isRunning]) {
+  if (self.state == AudioEngineState::AudioEngineStateRunning) {
     return true;
   }
 
-  if ([self.sourceNodes count] > 0 || self.inputNode != nil) {
+  if (([self.sourceNodes count] > 0) || self.inputNode != nil) {
     return [self startEngine];
   }
 
   return false;
 }
 
-- (void)stopIfNecessary
+- (void)pauseIfNecessary
 {
-  if (![self isRunning]) {
+  if (self.state == AudioEngineState::AudioEngineStatePaused) {
     return;
   }
 
-  if ([self.sourceNodes count] == 0 && self.inputNode == nil) {
-    [self stopEngine];
+  [self.audioEngine pause];
+  self.state = AudioEngineState::AudioEngineStatePaused;
+}
+
+- (void)stopIfNecessary
+{
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
+    return;
   }
+
+  [self stopEngine];
 }
 
-- (void)pauseIfNecessary
+- (void)stopIfPossible
 {
-  if (![self isRunning]) {
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
     return;
   }
 
-  for (NSString *sourceId in self.sourceStates) {
-    if ([self.sourceStates[sourceId] boolValue]) {
-      NSLog(@"state %@", self.sourceStates[sourceId]);
-      return;
-    }
+  bool hasInput = self.inputNode != nil;
+  bool hasSources = [self.sourceNodes count] > 0;
+
+  if (hasInput || hasSources) {
+    return;
   }
 
-  NSLog(@"[AudioEngine] pauseEngine");
-  [self.audioEngine pause];
+  [self stopEngine];
+}
+
+- (void)restartAudioEngine
+{
+  if ([self.audioEngine isRunning]) {
+    [self.audioEngine stop];
+  }
+
+  self.audioEngine = [[AVAudioEngine alloc] init];
+  [self rebuildAudioEngine];
 }
 
 - (void)logAudioEngineState
@@ -286,9 +299,4 @@ static AudioEngine *_sharedInstance = nil;
   NSLog(@"=======================================================");
 }
 
-- (bool)isSupposedToRun
-{
-  return self.isSupposedToBeRunning;
-}
-
 @end

package/ios/audioapi/ios/system/AudioSessionManager.h

@@ -8,34 +8,44 @@
 
 @property (nonatomic, weak) AVAudioSession *audioSession;
 
+// State tracking
 @property (nonatomic, assign) bool isActive;
-@property (nonatomic, assign) bool hasDirtySettings;
-@property (nonatomic, assign) AVAudioSessionMode sessionMode;
-@property (nonatomic, assign) AVAudioSessionCategory sessionCategory;
-@property (nonatomic, assign) AVAudioSessionCategoryOptions sessionOptions;
-@property (nonatomic, assign) bool allowHapticsAndSystemSoundsDuringRecording;
 @property (nonatomic, assign) bool shouldManageSession;
 
+// Session configuration options (desired by user)
+@property (nonatomic, assign) AVAudioSessionMode desiredMode;
+@property (nonatomic, assign) AVAudioSessionCategory desiredCategory;
+@property (nonatomic, assign) AVAudioSessionCategoryOptions desiredOptions;
+@property (nonatomic, assign) bool allowHapticsAndSounds;
+
 - (instancetype)init;
++ (instancetype)sharedInstance;
+
 - (void)cleanup;
-- (bool)configureAudioSession;
-- (bool)reconfigureAudioSession;
-- (void)markSettingsAsDirty;
 
-- (NSNumber *)getDevicePreferredSampleRate;
 - (void)setAudioSessionOptions:(NSString *)category
                           mode:(NSString *)mode
                        options:(NSArray *)options
                   allowHaptics:(BOOL)allowHaptics;
+
 - (bool)setActive:(bool)active;
+- (void)markInactive;
 - (void)disableSessionManagement;
 
+- (NSNumber *)getDevicePreferredSampleRate;
+- (NSNumber *)getDevicePreferredInputChannelCount;
+
 - (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve
                              reject:(RCTPromiseRejectBlock)reject;
+- (NSString *)requestRecordingPermissions;
+
 - (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve
                            reject:(RCTPromiseRejectBlock)reject;
+- (NSString *)checkRecordingPermissions;
 
 - (void)getDevicesInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
 - (NSArray<NSDictionary *> *)parseDeviceList:(NSArray<AVAudioSessionPortDescription *> *)devices;
 
+- (bool)isSessionActive;
+
 @end