react-native-audio-api 0.12.0-nightly-0d1a19d-20260120 → 0.12.0-nightly-6993a06-20260122

package/src/core/OscillatorNode.ts

@@ -1,17 +1,27 @@
 import { IOscillatorNode } from '../interfaces';
-import { OscillatorType } from '../types';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
 import PeriodicWave from './PeriodicWave';
 import { InvalidStateError } from '../errors';
-import { EventEmptyType } from '../events/types';
+import { OscillatorOptions } from '../defaults';
+import { TOscillatorOptions } from '../types';
 
 export default class OscillatorNode extends AudioScheduledSourceNode {
   readonly frequency: AudioParam;
   readonly detune: AudioParam;
 
-  constructor(context: BaseAudioContext, node: IOscillatorNode) {
+  constructor(context: BaseAudioContext, options?: TOscillatorOptions) {
+    const finalOptions: TOscillatorOptions = {
+      ...OscillatorOptions,
+      ...options,
+    };
+
+    if (finalOptions.periodicWave) {
+      finalOptions.type = 'custom';
+    }
+
+    const node = context.context.createOscillator(finalOptions);
     super(context, node);
     this.frequency = new AudioParam(node.frequency, context);
     this.detune = new AudioParam(node.detune, context);
@@ -35,14 +45,4 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
   public setPeriodicWave(wave: PeriodicWave): void {
     (this.node as IOscillatorNode).setPeriodicWave(wave.periodicWave);
   }
-
-  public override get onEnded(): ((event: EventEmptyType) => void) | undefined {
-    return super.onEnded as ((event: EventEmptyType) => void) | undefined;
-  }
-
-  public override set onEnded(
-    callback: ((event: EventEmptyType) => void) | null
-  ) {
-    super.onEnded = callback;
-  }
 }

package/src/core/PeriodicWave.ts

@@ -1,10 +1,44 @@
 import { IPeriodicWave } from '../interfaces';
+import BaseAudioContext from './BaseAudioContext';
+import { TPeriodicWaveOptions } from '../types';
+import { PeriodicWaveConstraints } from '../defaults';
+import { PeriodicWaveOptionsValidator } from '../options-validators';
+
+export function generateRealAndImag(
+  options?: TPeriodicWaveOptions
+): TPeriodicWaveOptions {
+  let real: Float32Array | undefined;
+  let imag: Float32Array | undefined;
+  if (!options || (!options.real && !options.imag)) {
+    real = new Float32Array(2);
+    imag = new Float32Array(2);
+    imag[1] = 1;
+  } else {
+    real = options.real;
+    imag = options.imag;
+    PeriodicWaveOptionsValidator.validate(options);
+    if (real && !imag) {
+      imag = new Float32Array(real.length);
+    } else if (!real && imag) {
+      real = new Float32Array(imag.length);
+    }
+  }
+  const norm: boolean = options?.disableNormalization
+    ? options.disableNormalization
+    : PeriodicWaveConstraints.disableNormalization!;
+  return { real, imag, disableNormalization: norm };
+}
 
 export default class PeriodicWave {
   /** @internal */
   public readonly periodicWave: IPeriodicWave;
 
-  constructor(periodicWave: IPeriodicWave) {
-    this.periodicWave = periodicWave;
+  constructor(context: BaseAudioContext, options?: TPeriodicWaveOptions) {
+    const finalOptions = generateRealAndImag(options);
+    this.periodicWave = context.context.createPeriodicWave(
+      finalOptions.real!,
+      finalOptions.imag!,
+      finalOptions.disableNormalization!
+    );
   }
 }

package/src/core/RecorderAdapterNode.ts

@@ -1,10 +1,15 @@
 import { IRecorderAdapterNode } from '../interfaces';
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class RecorderAdapterNode extends AudioNode {
   /** @internal */
   public wasConnected: boolean = false;
 
+  constructor(context: BaseAudioContext) {
+    super(context, context.context.createRecorderAdapter());
+  }
+
   /** @internal */
   public getNode(): IRecorderAdapterNode {
     return this.node as IRecorderAdapterNode;

package/src/core/StereoPannerNode.ts

@@ -1,4 +1,6 @@
 import { IStereoPannerNode } from '../interfaces';
+import { SteroPannerOptions } from '../defaults';
+import { TSteroPannerOptions } from '../types';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
@@ -6,7 +8,13 @@ import BaseAudioContext from './BaseAudioContext';
 export default class StereoPannerNode extends AudioNode {
   readonly pan: AudioParam;
 
-  constructor(context: BaseAudioContext, pan: IStereoPannerNode) {
+  constructor(context: BaseAudioContext, options?: TSteroPannerOptions) {
+    const finalOptions: TSteroPannerOptions = {
+      ...SteroPannerOptions,
+      ...options,
+    };
+    const pan: IStereoPannerNode =
+      context.context.createStereoPanner(finalOptions);
     super(context, pan);
     this.pan = new AudioParam(pan.pan, context);
   }

package/src/core/StreamerNode.ts

@@ -1,8 +1,36 @@
 import { IStreamerNode } from '../interfaces';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import { TStreamerOptions } from '../types';
+import { InvalidStateError, NotSupportedError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class StreamerNode extends AudioScheduledSourceNode {
+  private hasBeenSetup: boolean = false;
+  constructor(context: BaseAudioContext, options?: TStreamerOptions) {
+    const node = context.context.createStreamer(options);
+    if (!node) {
+      throw new NotSupportedError('StreamerNode requires FFmpeg build');
+    }
+    super(context, node);
+    if (options?.streamPath) {
+      if (this.initialize(options.streamPath)) {
+        this.hasBeenSetup = true;
+      }
+    }
+  }
+
   public initialize(streamPath: string): boolean {
-    return (this.node as IStreamerNode).initialize(streamPath);
+    if (this.hasBeenSetup) {
+      throw new InvalidStateError('Node is already setup');
+    }
+    const res = (this.node as IStreamerNode).initialize(streamPath);
+    if (res) {
+      this.hasBeenSetup = true;
+    }
+    return res;
+  }
+
+  public get streamPath(): string {
+    return (this.node as IStreamerNode).streamPath;
   }
 }

package/src/core/WaveShaperNode.ts

@@ -1,10 +1,27 @@
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
 import { InvalidStateError } from '../errors';
 import { IWaveShaperNode } from '../interfaces';
+import { WaveShaperOptions } from '../defaults';
+import { TWaveShaperOptions } from '../types';
 
 export default class WaveShaperNode extends AudioNode {
   private isCurveSet: boolean = false;
 
+  constructor(context: BaseAudioContext, options?: TWaveShaperOptions) {
+    const finalOptions: TWaveShaperOptions = {
+      ...WaveShaperOptions,
+      ...options,
+    };
+
+    const node = context.context.createWaveShaper(finalOptions);
+    super(context, node);
+
+    if (finalOptions.curve) {
+      this.isCurveSet = true;
+    }
+  }
+
   get curve(): Float32Array | null {
     if (!this.isCurveSet) {
       return null;

package/src/core/WorkletNode.ts

@@ -1,3 +1,32 @@
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioWorkletRuntime } from '../types';
+import AudioAPIModule from '../AudioAPIModule';
 
-export default class WorkletNode extends AudioNode {}
+export default class WorkletNode extends AudioNode {
+  constructor(
+    context: BaseAudioContext,
+    runtime: AudioWorkletRuntime,
+    callback: (audioData: Array<Float32Array>, channelCount: number) => void,
+    bufferLength: number,
+    inputChannelCount: number
+  ) {
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
+          'worklet';
+          const floatAudioData: Array<Float32Array> = audioBuffers.map(
+            (buffer) => new Float32Array(buffer)
+          );
+          callback(floatAudioData, channelCount);
+        }
+      );
+    const node = context.context.createWorkletNode(
+      shareableWorklet,
+      runtime === 'UIRuntime',
+      bufferLength,
+      inputChannelCount
+    );
+    super(context, node);
+  }
+}

package/src/core/WorkletProcessingNode.ts

@@ -1,3 +1,41 @@
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioWorkletRuntime } from '../types';
+import AudioAPIModule from '../AudioAPIModule';
 
-export default class WorkletProcessingNode extends AudioNode {}
+export default class WorkletProcessingNode extends AudioNode {
+  constructor(
+    context: BaseAudioContext,
+    runtime: AudioWorkletRuntime,
+    callback: (
+      inputData: Array<Float32Array>,
+      outputData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number
+    ) => void
+  ) {
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (
+          inputBuffers: Array<ArrayBuffer>,
+          outputBuffers: Array<ArrayBuffer>,
+          framesToProcess: number,
+          currentTime: number
+        ) => {
+          'worklet';
+          const inputData: Array<Float32Array> = inputBuffers.map(
+            (buffer) => new Float32Array(buffer, 0, framesToProcess)
+          );
+          const outputData: Array<Float32Array> = outputBuffers.map(
+            (buffer) => new Float32Array(buffer, 0, framesToProcess)
+          );
+          callback(inputData, outputData, framesToProcess, currentTime);
+        }
+      );
+    const node = context.context.createWorkletProcessingNode(
+      shareableWorklet,
+      runtime === 'UIRuntime'
+    );
+    super(context, node);
+  }
+}

package/src/core/WorkletSourceNode.ts

@@ -1,3 +1,38 @@
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioWorkletRuntime } from '../types';
+import AudioAPIModule from '../AudioAPIModule';
 
-export default class WorkletSourceNode extends AudioScheduledSourceNode {}
+export default class WorkletSourceNode extends AudioScheduledSourceNode {
+  constructor(
+    context: BaseAudioContext,
+    runtime: AudioWorkletRuntime,
+    callback: (
+      audioData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number,
+      startOffset: number
+    ) => void
+  ) {
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (
+          audioBuffers: Array<ArrayBuffer>,
+          framesToProcess: number,
+          currentTime: number,
+          startOffset: number
+        ) => {
+          'worklet';
+          const floatAudioData: Array<Float32Array> = audioBuffers.map(
+            (buffer) => new Float32Array(buffer)
+          );
+          callback(floatAudioData, framesToProcess, currentTime, startOffset);
+        }
+      );
+    const node = context.context.createWorkletSourceNode(
+      shareableWorklet,
+      runtime === 'UIRuntime'
+    );
+    super(context, node);
+  }
+}

package/src/defaults.ts

@@ -0,0 +1,100 @@
+import {
+  TAudioNodeOptions,
+  TGainOptions,
+  TSteroPannerOptions,
+  TConvolverOptions,
+  TConstantSourceOptions,
+  TPeriodicWaveConstraints,
+  TAnalyserOptions,
+  TBiquadFilterOptions,
+  TOscillatorOptions,
+  TBaseAudioBufferSourceOptions,
+  TAudioBufferSourceOptions,
+  TAudioBufferOptions,
+  TDelayOptions,
+  TWaveShaperOptions,
+} from './types';
+
+export const AudioNodeOptions: TAudioNodeOptions = {
+  channelCount: 2,
+  channelCountMode: 'max',
+  channelInterpretation: 'speakers',
+};
+
+export const GainOptions: TGainOptions = {
+  ...AudioNodeOptions,
+  gain: 1,
+};
+
+export const SteroPannerOptions: TSteroPannerOptions = {
+  ...AudioNodeOptions,
+  channelCountMode: 'clamped-max',
+  pan: 0,
+};
+
+export const AnalyserOptions: TAnalyserOptions = {
+  ...AudioNodeOptions,
+  fftSize: 2048,
+  minDecibels: -100,
+  maxDecibels: -30,
+  smoothingTimeConstant: 0.8,
+};
+
+export const BiquadFilterOptions: TBiquadFilterOptions = {
+  ...AudioNodeOptions,
+  Q: 1,
+  detune: 0,
+  frequency: 350,
+  gain: 0,
+  type: 'lowpass',
+};
+
+export const ConvolverOptions: TConvolverOptions = {
+  ...AudioNodeOptions,
+  disableNormalization: false,
+};
+
+export const ConstantSourceOptions: TConstantSourceOptions = {
+  offset: 1,
+};
+
+export const PeriodicWaveConstraints: TPeriodicWaveConstraints = {
+  disableNormalization: false,
+};
+
+export const OscillatorOptions: TOscillatorOptions = {
+  ...AudioNodeOptions,
+  type: 'sine',
+  frequency: 440,
+  detune: 0,
+};
+
+export const BaseAudioBufferSourceOptions: TBaseAudioBufferSourceOptions = {
+  playbackRate: 1,
+  detune: 0,
+  pitchCorrection: false,
+};
+
+export const AudioBufferSourceOptions: TAudioBufferSourceOptions = {
+  ...BaseAudioBufferSourceOptions,
+  loop: false,
+  loopStart: 0,
+  loopEnd: 0,
+};
+
+export const AudioBufferOptions: TAudioBufferOptions = {
+  numberOfChannels: 1,
+  length: 0, // always overwritten by provided value, only placeholder
+  sampleRate: 44100, // always overwritten by provided value, only placeholder
+};
+
+export const DelayOptions: TDelayOptions = {
+  ...AudioNodeOptions,
+  maxDelayTime: 1.0,
+  delayTime: 0.0,
+};
+
+export const WaveShaperOptions: TWaveShaperOptions = {
+  ...AudioNodeOptions,
+  oversample: 'none',
+};

package/src/events/types.ts

@@ -46,12 +46,13 @@ interface RemoteCommandEvents {
 type SystemEvents = RemoteCommandEvents & {
   volumeChange: EventTypeWithValue;
   interruption: OnInterruptionEventType;
+  duck: EventEmptyType;
   routeChange: OnRouteChangeEventType;
 };
 
-export interface OnEndedEventType extends EventEmptyType {
-  bufferId: string | undefined;
-  isLast: boolean | undefined;
+export interface OnBufferEndEventType {
+  bufferId: string;
+  isLastBufferInQueue: boolean;
 }
 
 /**
@@ -79,10 +80,11 @@ export interface OnAudioReadyEventType {
 }
 
 interface AudioAPIEvents {
-  ended: OnEndedEventType;
+  ended: EventEmptyType;
   loopEnded: EventEmptyType;
   audioReady: OnAudioReadyEventType;
   positionChanged: EventTypeWithValue;
+  bufferEnded: OnBufferEndEventType;
   audioError: EventEmptyType; // to change
   systemStateChanged: EventEmptyType; // to change
   recorderError: OnRecorderErrorEventType;

package/src/interfaces.ts

@@ -11,6 +11,20 @@ import type {
   OverSampleType,
   Result,
   WindowType,
+  TGainOptions,
+  TSteroPannerOptions,
+  TConvolverOptions,
+  TConstantSourceOptions,
+  TAnalyserOptions,
+  TBiquadFilterOptions,
+  TOscillatorOptions,
+  TBaseAudioBufferSourceOptions,
+  TAudioBufferSourceOptions,
+  TStreamerOptions,
+  TAudioBufferOptions,
+  TDelayOptions,
+  TIIRFilterOptions,
+  TWaveShaperOptions,
 } from './types';
 
 // IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
@@ -62,37 +76,35 @@ export interface IBaseAudioContext {
     shareableWorklet: ShareableWorkletCallback,
     shouldUseUiRuntime: boolean
   ): IWorkletProcessingNode;
-  createOscillator(): IOscillatorNode;
-  createConstantSource(): IConstantSourceNode;
-  createGain(): IGainNode;
-  createDelay(maxDelayTime: number): IDelayNode;
-  createStereoPanner(): IStereoPannerNode;
-  createBiquadFilter: () => IBiquadFilterNode;
-  createIIRFilter: (
-    feedforward: number[],
-    feedback: number[]
-  ) => IIIRFilterNode;
-  createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
+  createOscillator(oscillatorOptions: TOscillatorOptions): IOscillatorNode;
+  createConstantSource(
+    constantSourceOptions: TConstantSourceOptions
+  ): IConstantSourceNode;
+  createGain(gainOptions: TGainOptions): IGainNode;
+  createStereoPanner(
+    stereoPannerOptions: TSteroPannerOptions
+  ): IStereoPannerNode;
+  createBiquadFilter: (
+    biquadFilterOptions: TBiquadFilterOptions
+  ) => IBiquadFilterNode;
+  createBufferSource: (
+    audioBufferSourceOptions: TAudioBufferSourceOptions
+  ) => IAudioBufferSourceNode;
+  createDelay(delayOptions: TDelayOptions): IDelayNode;
+  createIIRFilter: (IIRFilterOptions: TIIRFilterOptions) => IIIRFilterNode;
   createBufferQueueSource: (
-    pitchCorrection: boolean
+    audioBufferQueueSourceOptions: TBaseAudioBufferSourceOptions
   ) => IAudioBufferQueueSourceNode;
-  createBuffer: (
-    channels: number,
-    length: number,
-    sampleRate: number
-  ) => IAudioBuffer;
+  createBuffer: (audioBufferOptions: TAudioBufferOptions) => IAudioBuffer;
   createPeriodicWave: (
     real: Float32Array,
     imag: Float32Array,
     disableNormalization: boolean
   ) => IPeriodicWave;
-  createAnalyser: () => IAnalyserNode;
-  createConvolver: (
-    buffer: IAudioBuffer | undefined,
-    disableNormalization: boolean
-  ) => IConvolverNode;
-  createStreamer: () => IStreamerNode | null; // null when FFmpeg is not enabled
-  createWaveShaper: () => IWaveShaperNode;
+  createAnalyser: (analyserOptions: TAnalyserOptions) => IAnalyserNode;
+  createConvolver: (convolverOptions: TConvolverOptions) => IConvolverNode;
+  createStreamer: (streamerOptions?: TStreamerOptions) => IStreamerNode | null; // null when FFmpeg is not enabled
+  createWaveShaper: (waveShaperOptions?: TWaveShaperOptions) => IWaveShaperNode;
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -186,6 +198,7 @@ export interface IOscillatorNode extends IAudioScheduledSourceNode {
 }
 
 export interface IStreamerNode extends IAudioNode {
+  readonly streamPath: string;
   initialize(streamPath: string): boolean;
 }
 
@@ -216,6 +229,9 @@ export interface IAudioBufferQueueSourceNode
   enqueueBuffer: (audioBuffer: IAudioBuffer) => string;
   start: (when?: number, offset?: number) => void;
   pause: () => void;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onBufferEnded: string;
 }
 
 export interface IConvolverNode extends IAudioNode {

package/src/options-validators.ts

@@ -0,0 +1,66 @@
+import { IndexSizeError, NotSupportedError } from './errors';
+import {
+  OptionsValidator,
+  TAnalyserOptions,
+  TConvolverOptions,
+  TOscillatorOptions,
+  TPeriodicWaveOptions,
+} from './types';
+
+export const AnalyserOptionsValidator: OptionsValidator<TAnalyserOptions> = {
+  validate(options: TAnalyserOptions): void {
+    const allowedFFTSize: number[] = [
+      32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
+    ];
+    if (options.fftSize && !allowedFFTSize.includes(options.fftSize)) {
+      throw new IndexSizeError(
+        `fftSize must be one of the following values: ${allowedFFTSize.join(
+          ', '
+        )}`
+      );
+    }
+  },
+};
+
+export const ConvolverOptionsValidator: OptionsValidator<TConvolverOptions> = {
+  validate(options: TConvolverOptions): void {
+    if (options.buffer) {
+      const numberOfChannels = options.buffer.numberOfChannels;
+      if (
+        numberOfChannels !== 1 &&
+        numberOfChannels !== 2 &&
+        numberOfChannels !== 4
+      ) {
+        throw new NotSupportedError(
+          `The number of channels provided (${numberOfChannels}) in impulse response for ConvolverNode buffer must be 1 or 2 or 4.`
+        );
+      }
+    }
+  },
+};
+
+export const OscillatorOptionsValidator: OptionsValidator<TOscillatorOptions> =
+  {
+    validate(options: TOscillatorOptions): void {
+      if (options.type === 'custom' && !options.periodicWave) {
+        throw new NotSupportedError(
+          "'type' cannot be set to 'custom' without providing a 'periodicWave'."
+        );
+      }
+    },
+  };
+
+export const PeriodicWaveOptionsValidator: OptionsValidator<TPeriodicWaveOptions> =
+  {
+    validate(options: TPeriodicWaveOptions): void {
+      if (
+        options.real &&
+        options.imag &&
+        options.real.length !== options.imag.length
+      ) {
+        throw new NotSupportedError(
+          "'real' and 'imag' arrays must have the same length"
+        );
+      }
+    },
+  };

package/src/specs/NativeAudioAPIModule.ts

@@ -6,6 +6,11 @@ import { AudioDevicesInfo, PermissionStatus } from '../system/types';
 type OptionsMap = { [key: string]: string | boolean | number | undefined };
 type NotificationOpResponse = { success: boolean; error?: string };
 type NotificationType = 'playback' | 'recording' | 'simple';
+type AudioFocusType =
+  | 'gain'
+  | 'gainTransient'
+  | 'gainTransientExclusive'
+  | 'gainTransientMayDuck';
 
 interface Spec extends TurboModule {
   install(): boolean;
@@ -22,7 +27,7 @@ interface Spec extends TurboModule {
   disableSessionManagement(): void;
 
   // Remote commands, system events and interruptions
-  observeAudioInterruptions(enabled: boolean): void;
+  observeAudioInterruptions(focusType: AudioFocusType, enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
   observeVolumeChanges(enabled: boolean): void;
 

package/src/specs/NativeAudioAPIModule.web.ts

@@ -1,5 +1,9 @@
 import { TurboModule } from 'react-native';
-import { AudioDevicesInfo, PermissionStatus } from '../system/types';
+import {
+  AudioDevicesInfo,
+  AudioFocusType,
+  PermissionStatus,
+} from '../system/types';
 
 // copy of spec from NativeAudioAPIModule.ts
 type OptionsMap = {
@@ -23,7 +27,7 @@ interface Spec extends TurboModule {
   disableSessionManagement(): void;
 
   // Remote commands, system events and interruptions
-  observeAudioInterruptions(enabled: boolean): void;
+  observeAudioInterruptions(focusType: AudioFocusType, enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
   observeVolumeChanges(enabled: boolean): void;
 

package/src/system/AudioManager.ts

@@ -7,6 +7,7 @@ import {
   IAudioManager,
   PermissionStatus,
   SessionOptions,
+  AudioFocusType,
 } from './types';
 
 class AudioManager implements IAudioManager {
@@ -43,8 +44,13 @@ class AudioManager implements IAudioManager {
     NativeAudioAPIModule.disableSessionManagement();
   }
 
-  observeAudioInterruptions(enabled: boolean) {
-    NativeAudioAPIModule.observeAudioInterruptions(enabled);
+  observeAudioInterruptions(param: AudioFocusType | boolean | null) {
+    if (typeof param === 'string') {
+      NativeAudioAPIModule.observeAudioInterruptions(param, true);
+    } else {
+      // audiofocusgain as default value if not provided
+      NativeAudioAPIModule.observeAudioInterruptions('gain', param === true);
+    }
   }
 
   /**