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

package/src/system/types.ts

@@ -30,6 +30,12 @@ export type IOSOption =
   | 'overrideMutedMicrophoneInterruption'
   | 'interruptSpokenAudioAndMixWithOthers';
 
+export type AudioFocusType =
+  | 'gain'
+  | 'gainTransient'
+  | 'gainTransientExclusive'
+  | 'gainTransientMayDuck';
+
 export interface SessionOptions {
   iosMode?: IOSMode;
   iosOptions?: IOSOption[];
@@ -60,7 +66,7 @@ export interface IAudioManager {
   disableSessionManagement(): void;
   observeAudioInterruptions(enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
-  observeVolumeChanges(enabled: boolean): void;
+  observeAudioInterruptions(param: AudioFocusType | boolean | null): void;
   addSystemEventListener<Name extends SystemEventName>(
     name: Name,
     callback: SystemEventCallback<Name>

package/src/types.ts

@@ -1,4 +1,5 @@
 import AudioBuffer from './core/AudioBuffer';
+import PeriodicWave from './core/PeriodicWave';
 
 export type Result<T> =
   | ({ status: 'success' } & T)
@@ -29,10 +30,6 @@ export type OscillatorType =
   | 'triangle'
   | 'custom';
 
-export interface PeriodicWaveConstraints {
-  disableNormalization: boolean;
-}
-
 export interface AudioContextOptions {
   sampleRate?: number;
 }
@@ -110,17 +107,99 @@ export interface FileInfo {
 
 export type WindowType = 'blackman' | 'hann';
 
-export interface AudioBufferBaseSourceNodeOptions {
-  pitchCorrection: boolean;
+export type ProcessorMode = 'processInPlace' | 'processThrough';
+
+export interface TAudioNodeOptions {
+  channelCount?: number;
+  channelCountMode?: ChannelCountMode;
+  channelInterpretation?: ChannelInterpretation;
 }
 
-export type ProcessorMode = 'processInPlace' | 'processThrough';
+export interface TGainOptions extends TAudioNodeOptions {
+  gain?: number;
+}
+
+export interface TSteroPannerOptions extends TAudioNodeOptions {
+  pan?: number;
+}
+
+export interface TAnalyserOptions extends TAudioNodeOptions {
+  fftSize?: number;
+  minDecibels?: number;
+  maxDecibels?: number;
+  smoothingTimeConstant?: number;
+}
 
-export interface ConvolverNodeOptions {
-  buffer?: AudioBuffer | null;
+export interface OptionsValidator<T> {
+  validate(options: T): void;
+}
+
+export interface TBiquadFilterOptions extends TAudioNodeOptions {
+  type?: BiquadFilterType;
+  frequency?: number;
+  detune?: number;
+  Q?: number;
+  gain?: number;
+}
+
+export interface TOscillatorOptions {
+  type?: OscillatorType;
+  frequency?: number;
+  detune?: number;
+  periodicWave?: PeriodicWave;
+}
+
+export interface TBaseAudioBufferSourceOptions {
+  detune?: number;
+  playbackRate?: number;
+  pitchCorrection?: boolean;
+}
+
+export interface TAudioBufferSourceOptions
+  extends TBaseAudioBufferSourceOptions {
+  buffer?: AudioBuffer;
+  loop?: boolean;
+  loopStart?: number;
+  loopEnd?: number;
+}
+
+export interface TConvolverOptions extends TAudioNodeOptions {
+  buffer?: AudioBuffer;
   disableNormalization?: boolean;
 }
 
+export interface TWebConvolverOptions {
+  buffer?: globalThis.AudioBuffer | null;
+  normalize?: boolean;
+}
+
+export interface TConstantSourceOptions {
+  offset?: number;
+}
+
+export interface TStreamerOptions {
+  streamPath?: string;
+}
+
+export interface TPeriodicWaveConstraints {
+  disableNormalization?: boolean;
+}
+
+export interface TPeriodicWaveOptions extends TPeriodicWaveConstraints {
+  real?: Float32Array;
+  imag?: Float32Array;
+}
+
+export interface TAudioBufferOptions {
+  numberOfChannels?: number;
+  length: number;
+  sampleRate: number;
+}
+
+export interface TIIRFilterOptions extends TAudioNodeOptions {
+  feedforward: number[];
+  feedback: number[];
+}
 export type OverSampleType = 'none' | '2x' | '4x';
 
 export interface AudioRecorderCallbackOptions {
@@ -145,9 +224,14 @@ export interface AudioRecorderCallbackOptions {
   channelCount: number;
 }
 
-export interface IIRFilterNodeOptions {
-  feedforward: number[];
-  feedback: number[];
+export interface TDelayOptions extends TAudioNodeOptions {
+  maxDelayTime?: number;
+  delayTime?: number;
+}
+
+export interface TWaveShaperOptions extends TAudioNodeOptions {
+  curve?: Float32Array;
+  oversample?: OverSampleType;
 }
 
 export type DecodeDataInput = number | string | ArrayBuffer;

package/src/web-core/AnalyserNode.tsx

@@ -1,5 +1,5 @@
 import AudioNode from './AudioNode';
-import { WindowType } from '../types';
+import { WindowType, TAnalyserOptions } from '../types';
 import BaseAudioContext from './BaseAudioContext';
 
 export default class AnalyserNode extends AudioNode {
@@ -9,7 +9,8 @@ export default class AnalyserNode extends AudioNode {
   maxDecibels: number;
   smoothingTimeConstant: number;
 
-  constructor(context: BaseAudioContext, node: globalThis.AnalyserNode) {
+  constructor(context: BaseAudioContext, analyserOptions?: TAnalyserOptions) {
+    const node = new globalThis.AnalyserNode(context.context, analyserOptions);
     super(context, node);
 
     this.fftSize = node.fftSize;
@@ -30,18 +31,26 @@ export default class AnalyserNode extends AudioNode {
   }
 
   public getByteFrequencyData(array: Uint8Array): void {
-    (this.node as globalThis.AnalyserNode).getByteFrequencyData(array);
+    (this.node as globalThis.AnalyserNode).getByteFrequencyData(
+      array as Uint8Array<ArrayBuffer>
+    );
   }
 
   public getByteTimeDomainData(array: Uint8Array): void {
-    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(array);
+    (this.node as globalThis.AnalyserNode).getByteTimeDomainData(
+      array as Uint8Array<ArrayBuffer>
+    );
   }
 
   public getFloatFrequencyData(array: Float32Array): void {
-    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(array);
+    (this.node as globalThis.AnalyserNode).getFloatFrequencyData(
+      array as Float32Array<ArrayBuffer>
+    );
   }
 
   public getFloatTimeDomainData(array: Float32Array): void {
-    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(array);
+    (this.node as globalThis.AnalyserNode).getFloatTimeDomainData(
+      array as Float32Array<ArrayBuffer>
+    );
   }
 }

package/src/web-core/AudioBuffer.tsx

@@ -1,4 +1,6 @@
 import { IndexSizeError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+import { TAudioBufferOptions } from '../types';
 
 export default class AudioBuffer {
   readonly length: number;
@@ -9,12 +11,24 @@ export default class AudioBuffer {
   /** @internal */
   public readonly buffer: globalThis.AudioBuffer;
 
-  constructor(buffer: globalThis.AudioBuffer) {
-    this.buffer = buffer;
-    this.length = buffer.length;
-    this.duration = buffer.duration;
-    this.sampleRate = buffer.sampleRate;
-    this.numberOfChannels = buffer.numberOfChannels;
+  constructor(buffer: globalThis.AudioBuffer);
+  constructor(context: BaseAudioContext, options: TAudioBufferOptions);
+
+  constructor(
+    contextOrBuffer: BaseAudioContext | globalThis.AudioBuffer,
+    options?: TAudioBufferOptions
+  ) {
+    let buf: globalThis.AudioBuffer;
+    if (contextOrBuffer instanceof BaseAudioContext) {
+      buf = new globalThis.AudioBuffer(options!);
+    } else {
+      buf = contextOrBuffer as globalThis.AudioBuffer;
+    }
+    this.buffer = buf;
+    this.length = buf.length;
+    this.duration = buf.duration;
+    this.sampleRate = buf.sampleRate;
+    this.numberOfChannels = buf.numberOfChannels;
   }
 
   public getChannelData(channel: number): Float32Array {