react-native-audio-api 0.11.0-alpha.1 → 0.11.0-alpha.10

package/src/system/notification/SimpleNotificationManager.ts

@@ -0,0 +1,175 @@
+import { AudioEventEmitter, AudioEventSubscription } from '../../events';
+import { NativeAudioAPIModule } from '../../specs';
+import type { NotificationManager, SimpleNotificationOptions } from './types';
+
+/// Simple notification manager for basic notifications with title and text.
+/// Implements the generic NotificationManager interface.
+// It is only a showcase
+class SimpleNotificationManager
+  implements
+    NotificationManager<
+      SimpleNotificationOptions,
+      SimpleNotificationOptions,
+      never
+    >
+{
+  private isRegistered_ = false;
+  private isShown_ = false;
+
+  private notificationKey = 'simple';
+  private audioEventEmitter: AudioEventEmitter;
+
+  constructor() {
+    this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
+  }
+
+  /// Register the simple notification (must be called before showing).
+  async register(): Promise<void> {
+    if (this.isRegistered_) {
+      console.warn('SimpleNotification is already registered');
+      return;
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.registerNotification(
+      'simple',
+      this.notificationKey
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isRegistered_ = true;
+  }
+
+  /// Show the notification with initial options.
+  async show(options: SimpleNotificationOptions): Promise<void> {
+    if (!this.isRegistered_) {
+      throw new Error(
+        'SimpleNotification must be registered before showing. Call register() first.'
+      );
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.showNotification(
+      this.notificationKey,
+      options as Record<string, string | number | boolean | undefined>
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isShown_ = true;
+  }
+
+  /// Update the notification with new options.
+  async update(options: SimpleNotificationOptions): Promise<void> {
+    if (!this.isShown_) {
+      console.warn('SimpleNotification is not shown. Call show() first.');
+      return;
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.updateNotification(
+      this.notificationKey,
+      options as Record<string, string | number | boolean | undefined>
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+  }
+
+  /// Hide the notification (can be shown again later).
+  async hide(): Promise<void> {
+    if (!this.isShown_) {
+      return;
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.hideNotification(
+      this.notificationKey
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isShown_ = false;
+  }
+
+  /// Unregister the notification (must register again to use).
+  async unregister(): Promise<void> {
+    if (!this.isRegistered_) {
+      return;
+    }
+
+    if (this.isShown_) {
+      await this.hide();
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.unregisterNotification(
+      this.notificationKey
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isRegistered_ = false;
+  }
+
+  /// Check if the notification is currently active.
+  async isActive(): Promise<boolean> {
+    if (!NativeAudioAPIModule) {
+      return false;
+    }
+
+    return await NativeAudioAPIModule.isNotificationActive(
+      this.notificationKey
+    );
+  }
+
+  isRegistered(): boolean {
+    return this.isRegistered_;
+  }
+
+  /// Add an event listener (SimpleNotification doesn't emit events).
+  addEventListener<T extends never>(
+    _eventName: T,
+    _callback: (event: never) => void
+  ): AudioEventSubscription {
+    // SimpleNotification doesn't emit events, return a no-op subscription
+    console.warn('SimpleNotification does not support event listeners');
+    return this.audioEventEmitter.addAudioEventListener(
+      // Using a valid event name for the no-op subscription
+      'playbackNotificationPlay',
+      () => {}
+    );
+  }
+
+  /// Remove an event listener.
+  removeEventListener(subscription: AudioEventSubscription): void {
+    subscription.remove();
+  }
+}
+
+export default new SimpleNotificationManager();

package/src/system/notification/index.ts

@@ -0,0 +1,4 @@
+export { default as PlaybackNotificationManager } from './PlaybackNotificationManager';
+export { default as RecordingNotificationManager } from './RecordingNotificationManager';
+export { default as SimpleNotificationManager } from './SimpleNotificationManager';
+export * from './types';

package/src/system/notification/types.ts

@@ -0,0 +1,111 @@
+import type { AudioEventSubscription } from '../../events';
+import { EventEmptyType, EventTypeWithValue } from '../../events/types';
+
+/// Generic notification manager interface that all notification managers should implement.
+/// Provides a consistent API for managing notification lifecycle and events.
+export interface NotificationManager<
+  TShowOptions,
+  TUpdateOptions,
+  TEventName extends NotificationEventName,
+> {
+  /// Register the notification (must be called before showing).
+  register(): Promise<void>;
+
+  /// Show the notification with initial options.
+  show(options: TShowOptions): Promise<void>;
+
+  /// Update the notification with new options.
+  update(options: TUpdateOptions): Promise<void>;
+
+  /// Hide the notification (can be shown again later).
+  hide(): Promise<void>;
+
+  /// Unregister the notification (must register again to use).
+  unregister(): Promise<void>;
+
+  /// Check if the notification is currently active.
+  isActive(): Promise<boolean>;
+
+  /// Add an event listener for notification events.
+  addEventListener<T extends TEventName>(
+    eventName: T,
+    callback: NotificationCallback<T>
+  ): AudioEventSubscription;
+
+  /// Remove an event listener.
+  removeEventListener(subscription: AudioEventSubscription): void;
+}
+
+/// Metadata and state information for playback notifications.
+export interface PlaybackNotificationInfo {
+  title?: string;
+  artist?: string;
+  album?: string;
+  artwork?: string | { uri: string };
+  androidSmallIcon?: string | { uri: string };
+  duration?: number;
+  elapsedTime?: number;
+  speed?: number;
+  state?: 'playing' | 'paused';
+}
+
+/// Available playback control actions.
+export type PlaybackControlName =
+  | 'play'
+  | 'pause'
+  | 'next'
+  | 'previous'
+  | 'skipForward'
+  | 'skipBackward'
+  | 'seekTo';
+
+/// Event names for playback notification actions.
+interface PlaybackNotificationEvent {
+  playbackNotificationPlay: EventEmptyType;
+  playbackNotificationPause: EventEmptyType;
+  playbackNotificationNext: EventEmptyType;
+  playbackNotificationPrevious: EventEmptyType;
+  playbackNotificationSkipForward: EventTypeWithValue;
+  playbackNotificationSkipBackward: EventTypeWithValue;
+  playbackNotificationSeekTo: EventTypeWithValue;
+  playbackNotificationDismissed: EventEmptyType;
+}
+
+export type PlaybackNotificationEventName = keyof PlaybackNotificationEvent;
+
+/// Metadata and state information for recording notifications.
+export interface RecordingNotificationInfo {
+  title?: string;
+  description?: string;
+  artwork?: string | { uri: string };
+  state?: 'recording' | 'stopped';
+  control?: RecordingControlName;
+  enabled?: boolean;
+}
+
+/// Available recording control actions.
+export type RecordingControlName = 'start' | 'stop';
+
+/// Event names for recording notification actions.
+interface RecordingNotificationEvent {
+  recordingNotificationStart: EventEmptyType;
+  recordingNotificationStop: EventEmptyType;
+  recordingNotificationDismissed: EventEmptyType;
+}
+
+export type RecordingNotificationEventName = keyof RecordingNotificationEvent;
+
+export type NotificationEvents = PlaybackNotificationEvent &
+  RecordingNotificationEvent;
+
+export type NotificationEventName = keyof NotificationEvents;
+
+export type NotificationCallback<Name extends NotificationEventName> = (
+  event: NotificationEvents[Name]
+) => void;
+
+/// Options for a simple notification with title and text.
+export interface SimpleNotificationOptions {
+  title?: string;
+  text?: string;
+}

package/src/system/types.ts

@@ -34,24 +34,6 @@ export interface SessionOptions {
   iosAllowHaptics?: boolean;
 }
 
-export type MediaState = 'state_playing' | 'state_paused';
-
-interface BaseLockScreenInfo {
-  [key: string]: string | boolean | number | undefined;
-}
-
-export interface LockScreenInfo extends BaseLockScreenInfo {
-  title?: string;
-  artwork?: string;
-  artist?: string;
-  album?: string;
-  duration?: number;
-  description?: string; // android only
-  state?: MediaState;
-  speed?: number;
-  elapsedTime?: number;
-}
-
 export type PermissionStatus = 'Undetermined' | 'Denied' | 'Granted';
 
 export interface AudioDeviceInfo {

package/src/types.ts

@@ -1,3 +1,9 @@
+import AudioBuffer from './core/AudioBuffer';
+
+export type Result<T> =
+  | ({ status: 'success' } & T)
+  | { status: 'error'; message: string };
+
 export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
 
 export type ChannelInterpretation = 'speakers' | 'discrete';
@@ -29,7 +35,6 @@ export interface PeriodicWaveConstraints {
 
 export interface AudioContextOptions {
   sampleRate?: number;
-  initSuspended?: boolean;
 }
 
 export interface OfflineAudioContextOptions {
@@ -39,68 +44,68 @@ export interface OfflineAudioContextOptions {
 }
 
 export enum FileDirectory {
-  Document = 1,
-  Cache = 2,
+  Document = 0,
+  Cache = 1,
 }
 
-export enum IOSFormat {
-  Wav = 1,
-  Caf = 2,
-  M4A = 3,
-  Flac = 4,
+export enum FileFormat {
+  Wav = 0,
+  Caf = 1,
+  M4A = 2,
+  Flac = 3,
 }
 
 export enum IOSAudioQuality {
-  Min = 1,
-  Low = 2,
-  Medium = 3,
-  High = 4,
-  Max = 5,
+  Min = 0,
+  Low = 1,
+  Medium = 2,
+  High = 3,
+  Max = 4,
 }
 
-export enum AndroidFormat {
-  Wav = 1,
-  Caf = 2,
-  M4A = 3,
-  Flac = 4,
+export enum BitDepth {
+  Bit16 = 0,
+  Bit24 = 1,
+  Bit32 = 2,
 }
 
 export enum FlacCompressionLevel {
-  L0 = 1,
-  L1 = 2,
-  L2 = 3,
-  L3 = 4,
-  L4 = 5,
-  L5 = 6,
-  L6 = 7,
-  L7 = 8,
-  L8 = 9,
+  L0 = 0,
+  L1 = 1,
+  L2 = 2,
+  L3 = 3,
+  L4 = 4,
+  L5 = 5,
+  L6 = 6,
+  L7 = 7,
+  L8 = 8,
 }
 
-export enum BitDepth {
-  Bit16 = 1,
-  Bit24 = 2,
-  Bit32 = 3,
+export interface FilePresetType {
+  bitRate: number;
+  sampleRate: number;
+  bitDepth: BitDepth;
+  iosQuality: IOSAudioQuality;
+  flacCompressionLevel: FlacCompressionLevel;
 }
 
-export interface AudioRecorderFileOptionsIOS {
-  format?: IOSFormat;
-  quality?: IOSAudioQuality;
-  flacCompressionLevel?: FlacCompressionLevel;
-}
+export interface AudioRecorderFileOptions {
+  channelCount?: number;
+  batchDurationSeconds?: number;
 
-export interface AudioRecorderFileOptionsAndroid {
-  format?: AndroidFormat;
-}
+  format?: FileFormat;
+  preset?: FilePresetType;
 
-export interface AudioRecorderFileOptions {
   directory?: FileDirectory;
-  sampleRate?: number;
-  channels?: number;
-  bitRate?: number;
-  bitDepth?: BitDepth;
-  ios?: AudioRecorderFileOptionsIOS;
-  android?: AudioRecorderFileOptionsAndroid;
+  subDirectory?: string;
+  fileNamePrefix?: string;
+  androidFlushIntervalMs?: number;
+}
+
+export interface FileInfo {
+  path: string;
+  size: number;
+  duration: number;
 }
 
 export type WindowType = 'blackman' | 'hann';
@@ -111,6 +116,11 @@ export interface AudioBufferBaseSourceNodeOptions {
 
 export type ProcessorMode = 'processInPlace' | 'processThrough';
 
+export interface ConvolverNodeOptions {
+  buffer?: AudioBuffer | null;
+  disableNormalization?: boolean;
+}
+
 export interface AudioRecorderCallbackOptions {
   /**
    * The desired sample rate (in Hz) for audio buffers delivered to the
@@ -133,8 +143,7 @@ export interface AudioRecorderCallbackOptions {
   channelCount: number;
 }
 
-export interface FileInfo {
-  path: string;
-  size: number;
-  duration: number;
+export interface IIRFilterNodeOptions {
+  feedforward: number[];
+  feedback: number[];
 }

package/src/utils/filePresets.ts

@@ -0,0 +1,47 @@
+import {
+  BitDepth,
+  FilePresetType,
+  FlacCompressionLevel,
+  IOSAudioQuality,
+} from '../types';
+
+const LowQuality: FilePresetType = {
+  sampleRate: 22050,
+  bitRate: 48000,
+  bitDepth: BitDepth.Bit16,
+  flacCompressionLevel: FlacCompressionLevel.L0,
+  iosQuality: IOSAudioQuality.Low,
+};
+
+const MediumQuality: FilePresetType = {
+  sampleRate: 44100,
+  bitRate: 128000,
+  bitDepth: BitDepth.Bit16,
+  flacCompressionLevel: FlacCompressionLevel.L3,
+  iosQuality: IOSAudioQuality.Medium,
+};
+
+const HighQuality: FilePresetType = {
+  sampleRate: 48000,
+  bitRate: 192000,
+  bitDepth: BitDepth.Bit24,
+  flacCompressionLevel: FlacCompressionLevel.L5,
+  iosQuality: IOSAudioQuality.High,
+};
+
+const LosslessQuality: FilePresetType = {
+  sampleRate: 48000,
+  bitRate: 320000,
+  bitDepth: BitDepth.Bit24,
+  flacCompressionLevel: FlacCompressionLevel.L8,
+  iosQuality: IOSAudioQuality.High,
+};
+
+const FilePreset = {
+  Low: LowQuality,
+  Medium: MediumQuality,
+  High: HighQuality,
+  Lossless: LosslessQuality,
+} as const;
+
+export default FilePreset;

package/src/utils/index.ts

@@ -1,26 +1,20 @@
-import type { ShareableWorkletCallback } from '../interfaces';
-export * from './bitEnums';
+import AudioAPIModule from '../AudioAPIModule';
 
-interface SimplifiedWorkletModule {
-  makeShareableCloneRecursive: (
-    workletCallback: ShareableWorkletCallback
-  ) => ShareableWorkletCallback;
+export function assertWorkletsEnabled() {
+  if (!AudioAPIModule.areWorkletsAvailable) {
+    throw new Error(
+      '[react-native-audio-api]: Worklets are not available. Please install react-native-worklets to use this feature.'
+    );
+  }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  createWorkletRuntime: (options?: any) => any;
+  if (!AudioAPIModule.isWorkletsVersionSupported) {
+    throw new Error(
+      `[react-native-audio-api]: Worklets version ${AudioAPIModule.workletsVersion} is not supported.
+      Please install react-native-worklets of one of the following versions: [${AudioAPIModule.supportedWorkletsVersion.join(', ')}] to use this feature.`
+    );
+  }
 }
 
 export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
-
-export let isWorkletsAvailable = false;
-export let workletsModule: SimplifiedWorkletModule;
-
-try {
-  workletsModule = require('react-native-worklets');
-  isWorkletsAvailable = true;
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-} catch (error) {
-  isWorkletsAvailable = false;
-}

package/src/web-core/AudioContext.tsx

@@ -3,6 +3,7 @@ import {
   PeriodicWaveConstraints,
   AudioContextOptions,
   AudioBufferBaseSourceNodeOptions,
+  IIRFilterNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -11,10 +12,14 @@ import AudioDestinationNode from './AudioDestinationNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
 import BiquadFilterNode from './BiquadFilterNode';
+import IIRFilterNode from './IIRFilterNode';
 import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import ConvolverNode from './ConvolverNode';
+import DelayNode from './DelayNode';
+import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
@@ -25,7 +30,7 @@ export default class AudioContext implements BaseAudioContext {
   readonly destination: AudioDestinationNode;
   readonly sampleRate: number;
 
-  constructor(options?: AudioContextOptions, _initSuspended: boolean = false) {
+  constructor(options?: AudioContextOptions) {
     if (
       options &&
       options.sampleRate &&
@@ -62,6 +67,10 @@ export default class AudioContext implements BaseAudioContext {
     return new GainNode(this, this.context.createGain());
   }
 
+  createDelay(maxDelayTime?: number): DelayNode {
+    return new DelayNode(this, this.context.createDelay(maxDelayTime));
+  }
+
   createStereoPanner(): StereoPannerNode {
     return new StereoPannerNode(this, this.context.createStereoPanner());
   }
@@ -70,6 +79,36 @@ export default class AudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
+  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode {
+    return new IIRFilterNode(
+      this,
+      this.context.createIIRFilter(options.feedforward, options.feedback)
+    );
+  }
+
+  createConvolver(options?: ConvolverNodeOptions): ConvolverNode {
+    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.`
+        );
+      }
+    }
+    const buffer = options?.buffer ?? null;
+    const disableNormalization = options?.disableNormalization ?? false;
+    return new ConvolverNode(
+      this,
+      this.context.createConvolver(),
+      buffer,
+      disableNormalization
+    );
+  }
+
   async createBufferSource(
     options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {

package/src/web-core/BaseAudioContext.tsx

@@ -1,14 +1,21 @@
-import { ContextState, PeriodicWaveConstraints } from '../types';
+import {
+  ContextState,
+  PeriodicWaveConstraints,
+  IIRFilterNodeOptions,
+} from '../types';
 import AnalyserNode from './AnalyserNode';
 import AudioDestinationNode from './AudioDestinationNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
 import BiquadFilterNode from './BiquadFilterNode';
+import IIRFilterNode from './IIRFilterNode';
 import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
+import ConvolverNode from './ConvolverNode';
+import DelayNode from './DelayNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -21,8 +28,11 @@ export default interface BaseAudioContext {
   createOscillator(): OscillatorNode;
   createConstantSource(): ConstantSourceNode;
   createGain(): GainNode;
+  createDelay(maxDelayTime?: number): DelayNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
+  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode;
+  createConvolver(): ConvolverNode;
   createBufferSource(): Promise<AudioBufferSourceNode>;
   createBuffer(
     numOfChannels: number,