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

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

@@ -0,0 +1,185 @@
+#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/utils/IOSRecorderCallback.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/Result.hpp>
+#include <algorithm>
+
+namespace audioapi {
+
+IOSRecorderCallback::IOSRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    int channelCount,
+    uint64_t callbackId)
+    : AudioRecorderCallback(
+          audioEventHandlerRegistry,
+          sampleRate,
+          bufferLength,
+          channelCount,
+          callbackId)
+{
+}
+
+IOSRecorderCallback::~IOSRecorderCallback()
+{
+  @autoreleasepool {
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (int i = 0; i < channelCount_; ++i) {
+      circularBus_[i]->zero();
+    }
+  }
+}
+
+/// @brief Prepares the IOSRecorderCallback for receiving audio data.
+/// This involves setting up the audio converter and buffers based on the provided input format.
+/// This method should be called from the JS thread only.
+/// @param bufferFormat The format of the incoming audio data.
+/// @param maxInputBufferLength The maximum length of the input buffer in frames.
+/// @returns Result indicating success or error with message.
+Result<NoneType, std::string> IOSRecorderCallback::prepare(
+    AVAudioFormat *bufferFormat,
+    size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    bufferFormat_ = bufferFormat;
+    converterInputBufferSize_ = maxInputBufferLength;
+
+    if (bufferFormat.sampleRate <= 0 || bufferFormat.channelCount == 0) {
+      return Result<NoneType, std::string>::Err(
+          "Invalid input format: sampleRate and channelCount must be greater than 0");
+    }
+
+    if (sampleRate_ <= 0 || channelCount_ == 0) {
+      return Result<NoneType, std::string>::Err(
+          "Invalid callback format: sampleRate and channelCount must be greater than 0");
+    }
+
+    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_];
+  }
+
+  return Result<NoneType, std::string>::Ok(None);
+}
+
+/// @brief Cleans up resources used by the IOSRecorderCallback.
+/// This method should be called from the JS thread only.
+void IOSRecorderCallback::cleanup()
+{
+  @autoreleasepool {
+    emitAudioData(true);
+
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (int i = 0; i < channelCount_; ++i) {
+      circularBus_[i]->zero();
+    }
+  }
+}
+
+/// @brief Receives audio data from the recorder, processes it, and stores it in the circular buffer.
+/// The data is converted using AVAudioConverter if the input format differs from the user desired callback format.
+/// This method runs on the audio thread.
+/// @param inputBuffer Pointer to the AudioBufferList containing the incoming audio data.
+/// @param numFrames Number of frames in the input buffer.
+void IOSRecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
+{
+  if (!isInitialized_.load(std::memory_order_acquire)) {
+    return;
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+
+    if (bufferFormat_.sampleRate == sampleRate_ && bufferFormat_.channelCount == channelCount_ &&
+        !bufferFormat_.isInterleaved) {
+      // Directly write to circular buffer
+      for (int 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;
+
+    __block BOOL handedOff = false;
+    AVAudioConverterInputBlock inputBlock = ^AVAudioBuffer *_Nullable(
+        AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      if (handedOff) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+
+      handedOff = true;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
+
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
+    converterOutputBuffer_.frameLength = sampleRate_ / bufferFormat_.sampleRate * numFrames;
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error during audio conversion, native error: ") +
+          [[error debugDescription] UTF8String]);
+      return;
+    }
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *inputChannel =
+          static_cast<float *>(converterOutputBuffer_.audioBufferList->mBuffers[i].mData);
+      circularBus_[i]->push_back(inputChannel, outputFrameCount);
+    }
+
+    emitAudioData();
+  }
+}
+
+} // namespace audioapi

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

@@ -5,30 +5,26 @@
 
 @class AudioSessionManager;
 
+typedef NS_ENUM(NSInteger, AudioEngineState) {
+  AudioEngineStateIdle = 0,
+  AudioEngineStateRunning,
+  AudioEngineStatePaused,
+  AudioEngineStateInterrupted
+};
+
 @interface AudioEngine : NSObject
 
-@property (nonatomic, assign) bool isInterrupted;
-@property (nonatomic, assign) bool isSupposedToBeRunning;
+@property (nonatomic, assign) AudioEngineState state;
 @property (nonatomic, strong) AVAudioEngine *audioEngine;
 @property (nonatomic, strong) NSMutableDictionary *sourceNodes;
 @property (nonatomic, strong) NSMutableDictionary *sourceFormats;
-@property (nonatomic, strong) NSMutableDictionary *sourceStates;
 @property (nonatomic, strong) AVAudioSinkNode *inputNode;
 @property (nonatomic, weak) AudioSessionManager *sessionManager;
 
-- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager;
-
+- (instancetype)init;
 + (instancetype)sharedInstance;
+
 - (void)cleanup;
-- (bool)rebuildAudioEngineAndStartIfNecessary;
-- (bool)restartAudioEngine;
-- (bool)startEngine;
-- (void)stopEngine;
-- (void)pauseEngine:(NSString *)sourceNodeId;
-- (bool)isRunning;
-- (void)markAsInterrupted;
-- (void)unmarkAsInterrupted;
-- (bool)isSupposedToRun;
 
 - (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format;
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
@@ -36,10 +32,19 @@
 - (void)attachInputNode:(AVAudioSinkNode *)inputNode;
 - (void)detachInputNode;
 
-- (void)logAudioEngineState;
+- (void)onInterruptionBegin;
+- (void)onInterruptionEnd:(bool)shouldResume;
+
+- (AudioEngineState)getState;
 
 - (bool)startIfNecessary;
-- (void)stopIfNecessary;
 - (void)pauseIfNecessary;
+- (void)stopIfNecessary;
+
+- (void)stopIfPossible;
+
+- (void)restartAudioEngine;
+
+- (void)logAudioEngineState;
 
 @end

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