react-native-audio-api 0.11.0-nightly-568a154-20251222 → 0.11.0-nightly-94b7f30-20251224

package/src/interfaces.ts

@@ -10,6 +10,7 @@ import type {
   OscillatorType,
   Result,
   WindowType,
+  OverSampleType,
 } from './types';
 
 // IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
@@ -91,6 +92,7 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IConvolverNode;
   createStreamer: () => IStreamerNode | null; // null when FFmpeg is not enabled
+  createWaveShaper: () => IWaveShaperNode;
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -289,6 +291,12 @@ export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
 
 export interface IWorkletProcessingNode extends IAudioNode {}
 
+export interface IWaveShaperNode extends IAudioNode {
+  readonly curve: Float32Array | null;
+  oversample: OverSampleType;
+
+  setCurve(curve: Float32Array | null): void;
+}
 export interface IAudioRecorderCallbackOptions
   extends AudioRecorderCallbackOptions {
   callbackId: string;
@@ -343,7 +351,7 @@ export interface IAudioDecoder {
 
 export interface IAudioStretcher {
   changePlaybackSpeed: (
-    arrayBuffer: AudioBuffer,
+    arrayBuffer: IAudioBuffer,
     playbackSpeed: number
   ) => Promise<IAudioBuffer>;
 }

package/src/specs/NativeAudioAPIModule.ts

@@ -1,9 +1,11 @@
 'use strict';
-import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
+
+import { TurboModuleRegistry, TurboModule } from 'react-native';
 import { AudioDevicesInfo, PermissionStatus } from '../system/types';
 
-type OptionsMap = { [key: string]: string | boolean | number | undefined };
+type OptionsMap = {
+  [key: string]: string | boolean | number | undefined;
+};
 type NotificationOpResponse = { success: boolean; error?: string };
 type NotificationType = 'playback' | 'recording' | 'simple';
 

package/src/specs/NativeAudioAPIModule.web.ts

@@ -0,0 +1,93 @@
+import { TurboModule } from 'react-native';
+import { AudioDevicesInfo, PermissionStatus } from '../system/types';
+
+// copy of spec from NativeAudioAPIModule.ts
+type OptionsMap = {
+  [key: string]: string | boolean | number | undefined;
+};
+type NotificationOpResponse = { success: boolean; error?: string };
+type NotificationType = 'playback' | 'recording' | 'simple';
+
+interface Spec extends TurboModule {
+  install(): boolean;
+  getDevicePreferredSampleRate(): number;
+
+  // AVAudioSession management
+  setAudioSessionActivity(enabled: boolean): Promise<boolean>;
+  setAudioSessionOptions(
+    category: string,
+    mode: string,
+    options: Array<string>,
+    allowHaptics: boolean
+  ): void;
+  disableSessionManagement(): void;
+
+  // Remote commands, system events and interruptions
+  observeAudioInterruptions(enabled: boolean): void;
+  activelyReclaimSession(enabled: boolean): void;
+  observeVolumeChanges(enabled: boolean): void;
+
+  // Permissions
+  requestRecordingPermissions(): Promise<PermissionStatus>;
+  checkRecordingPermissions(): Promise<PermissionStatus>;
+  requestNotificationPermissions(): Promise<PermissionStatus>;
+  checkNotificationPermissions(): Promise<PermissionStatus>;
+
+  // Audio devices
+  getDevicesInfo(): Promise<AudioDevicesInfo>;
+
+  // New notification system
+  registerNotification(
+    type: NotificationType,
+    key: string
+  ): Promise<NotificationOpResponse>;
+  showNotification(
+    key: string,
+    options: OptionsMap
+  ): Promise<NotificationOpResponse>;
+  updateNotification(
+    key: string,
+    options: OptionsMap
+  ): Promise<NotificationOpResponse>;
+  hideNotification(key: string): Promise<NotificationOpResponse>;
+  unregisterNotification(key: string): Promise<NotificationOpResponse>;
+  isNotificationActive(key: string): Promise<boolean>;
+}
+
+const mockAsync =
+  <T>(value: T) =>
+  () =>
+    Promise.resolve(value);
+const mockSync =
+  <T>(value: T) =>
+  () =>
+    value;
+
+const NativeAudioAPIModule: Spec = {
+  install: mockSync(true),
+  getDevicePreferredSampleRate: mockSync(0),
+  setAudioSessionActivity: mockAsync(true),
+  setAudioSessionOptions: mockSync({}),
+  disableSessionManagement: mockSync({}),
+  observeAudioInterruptions: mockSync({}),
+  activelyReclaimSession: mockSync({}),
+  observeVolumeChanges: mockSync({}),
+  requestRecordingPermissions: mockAsync('Granted' as PermissionStatus),
+  checkRecordingPermissions: mockAsync('Granted' as PermissionStatus),
+  requestNotificationPermissions: mockAsync('Granted' as PermissionStatus),
+  checkNotificationPermissions: mockAsync('Granted' as PermissionStatus),
+  getDevicesInfo: mockAsync({
+    availableInputs: [],
+    availableOutputs: [],
+    currentInputs: [],
+    currentOutputs: [],
+  }),
+  registerNotification: mockAsync({ success: true }),
+  showNotification: mockAsync({ success: true }),
+  updateNotification: mockAsync({ success: true }),
+  hideNotification: mockAsync({ success: true }),
+  unregisterNotification: mockAsync({ success: true }),
+  isNotificationActive: mockAsync(false),
+};
+
+export { NativeAudioAPIModule };

package/src/system/AudioManager.ts

@@ -1,24 +1,29 @@
-import { SessionOptions, PermissionStatus, AudioDevicesInfo } from './types';
+import {
+  SessionOptions,
+  PermissionStatus,
+  AudioDevicesInfo,
+  IAudioManager,
+} from './types';
 import { SystemEventName, SystemEventCallback } from '../events/types';
 import { AudioEventEmitter, AudioEventSubscription } from '../events';
 import { NativeAudioAPIModule } from '../specs';
 
-class AudioManager {
+class AudioManager implements IAudioManager {
   private readonly audioEventEmitter: AudioEventEmitter;
   constructor() {
     this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
   }
 
   getDevicePreferredSampleRate(): number {
-    return NativeAudioAPIModule!.getDevicePreferredSampleRate();
+    return NativeAudioAPIModule.getDevicePreferredSampleRate();
   }
 
   setAudioSessionActivity(enabled: boolean): Promise<boolean> {
-    return NativeAudioAPIModule!.setAudioSessionActivity(enabled);
+    return NativeAudioAPIModule.setAudioSessionActivity(enabled);
   }
 
   setAudioSessionOptions(options: SessionOptions) {
-    NativeAudioAPIModule!.setAudioSessionOptions(
+    NativeAudioAPIModule.setAudioSessionOptions(
       options.iosCategory ?? '',
       options.iosMode ?? '',
       options.iosOptions ?? [],
@@ -27,11 +32,11 @@ class AudioManager {
   }
 
   disableSessionManagement() {
-    NativeAudioAPIModule!.disableSessionManagement();
+    NativeAudioAPIModule.disableSessionManagement();
   }
 
   observeAudioInterruptions(enabled: boolean) {
-    NativeAudioAPIModule!.observeAudioInterruptions(enabled);
+    NativeAudioAPIModule.observeAudioInterruptions(enabled);
   }
 
   /**
@@ -48,11 +53,11 @@ class AudioManager {
    * interval polling to check if other audio is playing.
    */
   activelyReclaimSession(enabled: boolean) {
-    NativeAudioAPIModule!.activelyReclaimSession(enabled);
+    NativeAudioAPIModule.activelyReclaimSession(enabled);
   }
 
   observeVolumeChanges(enabled: boolean) {
-    NativeAudioAPIModule!.observeVolumeChanges(enabled);
+    NativeAudioAPIModule.observeVolumeChanges(enabled);
   }
 
   addSystemEventListener<Name extends SystemEventName>(
@@ -63,23 +68,23 @@ class AudioManager {
   }
 
   async requestRecordingPermissions(): Promise<PermissionStatus> {
-    return NativeAudioAPIModule!.requestRecordingPermissions();
+    return NativeAudioAPIModule.requestRecordingPermissions();
   }
 
   async checkRecordingPermissions(): Promise<PermissionStatus> {
-    return NativeAudioAPIModule!.checkRecordingPermissions();
+    return NativeAudioAPIModule.checkRecordingPermissions();
   }
 
   async requestNotificationPermissions(): Promise<PermissionStatus> {
-    return NativeAudioAPIModule!.requestNotificationPermissions();
+    return NativeAudioAPIModule.requestNotificationPermissions();
   }
 
   async checkNotificationPermissions(): Promise<PermissionStatus> {
-    return NativeAudioAPIModule!.checkNotificationPermissions();
+    return NativeAudioAPIModule.checkNotificationPermissions();
   }
 
   async getDevicesInfo(): Promise<AudioDevicesInfo> {
-    return NativeAudioAPIModule!.getDevicesInfo();
+    return NativeAudioAPIModule.getDevicesInfo();
   }
 }
 

package/src/system/notification/types.ts

@@ -30,7 +30,7 @@ export interface NotificationManager<
   addEventListener<T extends TEventName>(
     eventName: T,
     callback: NotificationCallback<T>
-  ): AudioEventSubscription;
+  ): AudioEventSubscription | undefined;
 
   /// Remove an event listener.
   removeEventListener(subscription: AudioEventSubscription): void;

package/src/system/types.ts

@@ -1,3 +1,6 @@
+import type { SystemEventName, SystemEventCallback } from '../events/types';
+import type { AudioEventSubscription } from '../events';
+
 export type IOSCategory =
   | 'record'
   | 'ambient'
@@ -49,3 +52,22 @@ export interface AudioDevicesInfo {
   currentInputs: AudioDeviceList; // iOS only
   currentOutputs: AudioDeviceList; // iOS only
 }
+
+export interface IAudioManager {
+  getDevicePreferredSampleRate(): number;
+  setAudioSessionActivity(enabled: boolean): Promise<boolean>;
+  setAudioSessionOptions(options: SessionOptions): void;
+  disableSessionManagement(): void;
+  observeAudioInterruptions(enabled: boolean): void;
+  activelyReclaimSession(enabled: boolean): void;
+  observeVolumeChanges(enabled: boolean): void;
+  addSystemEventListener<Name extends SystemEventName>(
+    name: Name,
+    callback: SystemEventCallback<Name>
+  ): AudioEventSubscription | undefined;
+  requestRecordingPermissions(): Promise<PermissionStatus>;
+  checkRecordingPermissions(): Promise<PermissionStatus>;
+  requestNotificationPermissions(): Promise<PermissionStatus>;
+  checkNotificationPermissions(): Promise<PermissionStatus>;
+  getDevicesInfo(): Promise<AudioDevicesInfo>;
+}

package/src/types.ts

@@ -121,6 +121,8 @@ export interface ConvolverNodeOptions {
   disableNormalization?: boolean;
 }
 
+export type OverSampleType = 'none' | '2x' | '4x';
+
 export interface AudioRecorderCallbackOptions {
   /**
    * The desired sample rate (in Hz) for audio buffers delivered to the

package/src/web-core/AudioContext.tsx

@@ -23,6 +23,7 @@ import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
+import WaveShaperNode from './WaveShaperNode';
 
 export default class AudioContext implements BaseAudioContext {
   readonly context: globalThis.AudioContext;
@@ -175,6 +176,10 @@ export default class AudioContext implements BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
+  createWaveShaper(): WaveShaperNode {
+    return new WaveShaperNode(this, this.context.createWaveShaper());
+  }
+
   async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
     const arrayBuffer = await fetch(source).then((response) =>
       response.arrayBuffer()

package/src/web-core/BaseAudioContext.tsx

@@ -8,6 +8,7 @@ import AudioDestinationNode from './AudioDestinationNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
 import BiquadFilterNode from './BiquadFilterNode';
+import DelayNode from './DelayNode';
 import IIRFilterNode from './IIRFilterNode';
 import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
@@ -15,7 +16,7 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 import ConvolverNode from './ConvolverNode';
-import DelayNode from './DelayNode';
+import WaveShaperNode from './WaveShaperNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -45,6 +46,7 @@ export default interface BaseAudioContext {
     constraints?: PeriodicWaveConstraints
   ): PeriodicWave;
   createAnalyser(): AnalyserNode;
+  createWaveShaper(): WaveShaperNode;
   decodeAudioDataSource(source: string): Promise<AudioBuffer>;
   decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer>;
 }

package/src/web-core/OfflineAudioContext.tsx

@@ -18,6 +18,7 @@ import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
+import WaveShaperNode from './WaveShaperNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConvolverNode from './ConvolverNode';
@@ -181,6 +182,10 @@ export default class OfflineAudioContext implements BaseAudioContext {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
 
+  createWaveShaper(): WaveShaperNode {
+    return new WaveShaperNode(this, this.context.createWaveShaper());
+  }
+
   async decodeAudioDataSource(source: string): Promise<AudioBuffer> {
     const arrayBuffer = await fetch(source).then((response) =>
       response.arrayBuffer()

package/src/web-core/WaveShaperNode.tsx

@@ -0,0 +1,42 @@
+import { InvalidStateError } from '../errors';
+import AudioNode from './AudioNode';
+
+export default class WaveShaperNode extends AudioNode {
+  private isCurveSet: boolean = false;
+
+  get curve(): Float32Array | null {
+    if (!this.isCurveSet) {
+      return null;
+    }
+
+    return (this.node as globalThis.WaveShaperNode).curve;
+  }
+
+  get oversample(): OverSampleType {
+    return (this.node as globalThis.WaveShaperNode).oversample;
+  }
+
+  set curve(curve: Float32Array | null) {
+    if (curve !== null) {
+      if (this.isCurveSet) {
+        throw new InvalidStateError(
+          'The curve can only be set once and cannot be changed afterwards.'
+        );
+      }
+
+      if (curve.length < 2) {
+        throw new InvalidStateError(
+          'The curve must have at least two values if not null.'
+        );
+      }
+
+      this.isCurveSet = true;
+    }
+
+    (this.node as globalThis.WaveShaperNode).curve = curve;
+  }
+
+  set oversample(value: OverSampleType) {
+    (this.node as globalThis.WaveShaperNode).oversample = value;
+  }
+}

package/src/web-system/AudioManager.ts

@@ -0,0 +1,33 @@
+import type { IAudioManager, PermissionStatus } from '../system/types';
+
+const mockAsync =
+  <T>(value: T) =>
+  () =>
+    Promise.resolve(value);
+const mockSync =
+  <T>(value: T) =>
+  () =>
+    value;
+
+class AudioManager implements IAudioManager {
+  getDevicePreferredSampleRate = mockSync(44100);
+  setAudioSessionActivity = mockAsync(true);
+  setAudioSessionOptions = mockSync({});
+  disableSessionManagement = mockSync({});
+  observeAudioInterruptions = mockSync(true);
+  activelyReclaimSession = mockSync({});
+  observeVolumeChanges = mockSync({});
+  addSystemEventListener = mockSync(undefined);
+  requestRecordingPermissions = mockAsync('Granted' as PermissionStatus);
+  checkRecordingPermissions = mockAsync('Granted' as PermissionStatus);
+  requestNotificationPermissions = mockAsync('Granted' as PermissionStatus);
+  checkNotificationPermissions = mockAsync('Granted' as PermissionStatus);
+  getDevicesInfo = mockAsync({
+    availableInputs: [],
+    availableOutputs: [],
+    currentInputs: [],
+    currentOutputs: [],
+  });
+}
+
+export default new AudioManager();

package/src/web-system/index.ts

@@ -1 +1,2 @@
 export * from './notification';
+export { default as AudioManager } from './AudioManager';