react-native-audio-api 0.6.0-rc.5 → 0.6.0

package/src/core/AudioRecorder.ts

@@ -1,56 +1,14 @@
-import {
-  IAudioRecorder,
-  IErrorCallback,
-  IAudioReadyCallback,
-  IStatusChangeCallback,
-  IAudioBuffer,
-} from '../interfaces';
-import { AudioRecorderStatus, AudioRecorderOptions } from '../types';
+import { IAudioRecorder } from '../interfaces';
+import { AudioRecorderOptions } from '../types';
 import AudioBuffer from './AudioBuffer';
-
-export type AudioReadyCallback = (
-  buffer: AudioBuffer,
-  numFrames: number,
-  when: number
-) => void;
-
-export type ErrorCallback = (error: Error) => void;
-
-export type StatusChangeCallback = (
-  status: AudioRecorderStatus,
-  previousStatus: AudioRecorderStatus
-) => void;
+import { OnAudioReadyEventType } from '../events/types';
+import { AudioEventEmitter } from '../events';
 
 export default class AudioRecorder {
   protected readonly recorder: IAudioRecorder;
-  private onAudioReadyCallback: AudioReadyCallback | null = null;
-  private onErrorCallback: ErrorCallback | null = null;
-  private onStatusChangeCallback: StatusChangeCallback | null = null;
-
-  private onAudioReadyInternal: IAudioReadyCallback = (
-    buffer: IAudioBuffer,
-    numFrames: number,
-    when: number
-  ) => {
-    if (this.onAudioReadyCallback) {
-      this.onAudioReadyCallback(new AudioBuffer(buffer), numFrames, when);
-    }
-  };
-
-  private onErrorInternal: IErrorCallback = (error: Error) => {
-    if (this.onErrorCallback) {
-      this.onErrorCallback(error);
-    }
-  };
-
-  private onStatusChangeInternal: IStatusChangeCallback = (
-    status: AudioRecorderStatus,
-    previousStatus: AudioRecorderStatus
-  ) => {
-    if (this.onStatusChangeCallback) {
-      this.onStatusChangeCallback(status, previousStatus);
-    }
-  };
+  private readonly audioEventEmitter = new AudioEventEmitter(
+    global.AudioEventEmitter
+  );
 
   constructor(options: AudioRecorderOptions) {
     this.recorder = global.createAudioRecorder(options);
@@ -64,18 +22,20 @@ export default class AudioRecorder {
     this.recorder.stop();
   }
 
-  public onAudioReady(callback: AudioReadyCallback): void {
-    this.onAudioReadyCallback = callback;
-    this.recorder.onAudioReady(this.onAudioReadyInternal);
-  }
-
-  public onError(callback: ErrorCallback): void {
-    this.onErrorCallback = callback;
-    this.recorder.onError(this.onErrorInternal);
-  }
-
-  public onStatusChange(callback: StatusChangeCallback): void {
-    this.onStatusChangeCallback = callback;
-    this.recorder.onStatusChange(this.onStatusChangeInternal);
+  public onAudioReady(callback: (event: OnAudioReadyEventType) => void): void {
+    const onAudioReadyCallback = (event: OnAudioReadyEventType) => {
+      callback({
+        buffer: new AudioBuffer(event.buffer),
+        numFrames: event.numFrames,
+        when: event.when,
+      });
+    };
+
+    const subscription = this.audioEventEmitter.addAudioEventListener(
+      'audioReady',
+      onAudioReadyCallback
+    );
+
+    this.recorder.onAudioReady = subscription.subscriptionId;
   }
 }

package/src/core/AudioScheduledSourceNode.ts

@@ -1,9 +1,14 @@
 import { IAudioScheduledSourceNode } from '../interfaces';
 import AudioNode from './AudioNode';
 import { InvalidStateError, RangeError } from '../errors';
+import { EventTypeWithValue } from '../events/types';
+import { AudioEventEmitter } from '../events';
 
 export default class AudioScheduledSourceNode extends AudioNode {
   protected hasBeenStarted: boolean = false;
+  private readonly audioEventEmitter = new AudioEventEmitter(
+    global.AudioEventEmitter
+  );
 
   public start(when: number = 0): void {
     if (when < 0) {
@@ -37,7 +42,13 @@ export default class AudioScheduledSourceNode extends AudioNode {
   }
 
   // eslint-disable-next-line accessor-pairs
-  public set onended(callback: (arg?: number) => void) {
-    (this.node as IAudioScheduledSourceNode).onended = callback;
+  public set onended(callback: (event: EventTypeWithValue) => void) {
+    const subscription = this.audioEventEmitter.addAudioEventListener(
+      'ended',
+      callback
+    );
+
+    (this.node as IAudioScheduledSourceNode).onended =
+      subscription.subscriptionId;
   }
 }

package/src/core/BiquadFilterNode.ts

@@ -13,10 +13,10 @@ export default class BiquadFilterNode extends AudioNode {
 
   constructor(context: BaseAudioContext, biquadFilter: IBiquadFilterNode) {
     super(context, biquadFilter);
-    this.frequency = new AudioParam(biquadFilter.frequency);
-    this.detune = new AudioParam(biquadFilter.detune);
-    this.Q = new AudioParam(biquadFilter.Q);
-    this.gain = new AudioParam(biquadFilter.gain);
+    this.frequency = new AudioParam(biquadFilter.frequency, context);
+    this.detune = new AudioParam(biquadFilter.detune, context);
+    this.Q = new AudioParam(biquadFilter.Q, context);
+    this.gain = new AudioParam(biquadFilter.gain, context);
   }
 
   public get type(): BiquadFilterType {

package/src/core/GainNode.ts

@@ -8,6 +8,6 @@ export default class GainNode extends AudioNode {
 
   constructor(context: BaseAudioContext, gain: IGainNode) {
     super(context, gain);
-    this.gain = new AudioParam(gain.gain);
+    this.gain = new AudioParam(gain.gain, context);
   }
 }

package/src/core/OscillatorNode.ts

@@ -12,8 +12,8 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
 
   constructor(context: BaseAudioContext, node: IOscillatorNode) {
     super(context, node);
-    this.frequency = new AudioParam(node.frequency);
-    this.detune = new AudioParam(node.detune);
+    this.frequency = new AudioParam(node.frequency, context);
+    this.detune = new AudioParam(node.detune, context);
     this.type = node.type;
   }
 

package/src/core/StereoPannerNode.ts

@@ -8,6 +8,6 @@ export default class StereoPannerNode extends AudioNode {
 
   constructor(context: BaseAudioContext, pan: IStereoPannerNode) {
     super(context, pan);
-    this.pan = new AudioParam(pan.pan);
+    this.pan = new AudioParam(pan.pan, context);
   }
 }

package/src/events/AudioEventEmitter.ts

@@ -0,0 +1,29 @@
+import { AudioEventName, AudioEventCallback } from './types';
+import AudioEventSubscription from './AudioEventSubscription';
+import { IAudioEventEmitter } from '../interfaces';
+
+export default class AudioEventEmitter {
+  private readonly audioEventEmitter: IAudioEventEmitter;
+
+  constructor(audioEventEmitter: IAudioEventEmitter) {
+    this.audioEventEmitter = audioEventEmitter;
+  }
+
+  addAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    callback: AudioEventCallback<Name>
+  ): AudioEventSubscription {
+    const subscriptionId = this.audioEventEmitter.addAudioEventListener(
+      name,
+      callback
+    );
+    return new AudioEventSubscription(subscriptionId, name, this);
+  }
+
+  removeAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    subscriptionId: string
+  ): void {
+    this.audioEventEmitter.removeAudioEventListener(name, subscriptionId);
+  }
+}

package/src/events/AudioEventSubscription.ts

@@ -0,0 +1,26 @@
+import { AudioEventName } from './types';
+import { AudioEventEmitter } from './';
+
+export default class AudioEventSubscription {
+  private readonly audioEventEmitter: AudioEventEmitter;
+  private readonly eventName: AudioEventName;
+  /** @internal */
+  public readonly subscriptionId: string;
+
+  constructor(
+    subscriptionId: string,
+    eventName: AudioEventName,
+    audioEventEmitter: AudioEventEmitter
+  ) {
+    this.subscriptionId = subscriptionId;
+    this.eventName = eventName;
+    this.audioEventEmitter = audioEventEmitter;
+  }
+
+  public remove(): void {
+    this.audioEventEmitter.removeAudioEventListener(
+      this.eventName,
+      this.subscriptionId
+    );
+  }
+}

package/src/events/index.ts

@@ -0,0 +1,4 @@
+import AudioEventEmitter from './AudioEventEmitter';
+import AudioEventSubscription from './AudioEventSubscription';
+
+export { AudioEventEmitter, AudioEventSubscription };

package/src/events/types.ts

@@ -0,0 +1,64 @@
+import AudioBuffer from '../core/AudioBuffer';
+
+interface EventEmptyType {}
+
+export interface EventTypeWithValue {
+  value: number;
+}
+
+interface OnInterruptionEventType {
+  type: 'ended' | 'began';
+  shouldResume: boolean;
+}
+
+interface OnRouteChangeEventType {
+  reason: string;
+}
+
+interface SystemEvents {
+  remotePlay: EventEmptyType;
+  remotePause: EventEmptyType;
+  remoteStop: EventEmptyType;
+  remoteTogglePlayPause: EventEmptyType;
+  remoteChangePlaybackRate: EventTypeWithValue;
+  remoteNextTrack: EventEmptyType;
+  remotePreviousTrack: EventEmptyType;
+  remoteSkipForward: EventEmptyType;
+  remoteSkipBackward: EventEmptyType;
+  remoteSeekForward: EventTypeWithValue;
+  remoteSeekBackward: EventTypeWithValue;
+  remoteChangePlaybackPosition: EventTypeWithValue;
+  volumeChange: EventTypeWithValue;
+  interruption: OnInterruptionEventType;
+  routeChange: OnRouteChangeEventType;
+}
+
+export interface OnAudioReadyEventType {
+  buffer: AudioBuffer;
+  numFrames: number;
+  when: number;
+}
+
+interface AudioAPIEvents {
+  ended: EventTypeWithValue;
+  audioReady: OnAudioReadyEventType;
+  audioError: EventEmptyType; // to change
+  systemStateChanged: EventEmptyType; // to change
+}
+
+type AudioEvents = SystemEvents & AudioAPIEvents;
+
+export type SystemEventName = keyof SystemEvents;
+export type SystemEventCallback<Name extends SystemEventName> = (
+  event: SystemEvents[Name]
+) => void;
+
+export type AudioAPIEventName = keyof AudioAPIEvents;
+export type AudioAPIEventCallback<Name extends AudioAPIEventName> = (
+  event: AudioAPIEvents[Name]
+) => void;
+
+export type AudioEventName = keyof AudioEvents;
+export type AudioEventCallback<Name extends AudioEventName> = (
+  event: AudioEvents[Name]
+) => void;

package/src/hooks/useSytemVolume.ts

@@ -6,11 +6,12 @@ export default function useSystemVolume() {
 
   useEffect(() => {
     AudioManager.observeVolumeChanges(true);
-    const listener = AudioManager.enableRemoteEvent('volumeChange', (e) => {
+    const listener = AudioManager.enableSystemEvent('volumeChange', (e) => {
       setVolume(parseFloat(e.value.toFixed(2)));
     });
     return () => {
       listener?.remove();
+
       AudioManager.observeVolumeChanges(false);
     };
   }, []);

package/src/interfaces.ts

@@ -4,9 +4,9 @@ import {
   OscillatorType,
   BiquadFilterType,
   ChannelCountMode,
-  AudioRecorderStatus,
   ChannelInterpretation,
 } from './types';
+import { AudioEventName, AudioEventCallback } from './events/types';
 
 export interface IBaseAudioContext {
   readonly destination: IAudioDestinationNode;
@@ -54,8 +54,8 @@ export interface IAudioNode {
   readonly channelCountMode: ChannelCountMode;
   readonly channelInterpretation: ChannelInterpretation;
 
-  connect: (node: IAudioNode) => void;
-  disconnect: (node?: IAudioNode) => void;
+  connect: (destination: IAudioNode | IAudioParam) => void;
+  disconnect: (destination?: IAudioNode | IAudioParam) => void;
 }
 
 export interface IGainNode extends IAudioNode {
@@ -85,7 +85,9 @@ export interface IAudioDestinationNode extends IAudioNode {}
 export interface IAudioScheduledSourceNode extends IAudioNode {
   start(when?: number): void;
   stop: (when: number) => void;
-  onended: (arg?: number) => void | null;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onended: string;
 }
 
 export interface IOscillatorNode extends IAudioScheduledSourceNode {
@@ -165,24 +167,21 @@ export interface IAnalyserNode extends IAudioNode {
   getByteTimeDomainData: (array: Uint8Array) => void;
 }
 
-export type IAudioReadyCallback = (
-  buffer: IAudioBuffer,
-  numFrames: number,
-  when: number
-) => void;
-
-export type IErrorCallback = (error: Error) => void;
-
-export type IStatusChangeCallback = (
-  status: AudioRecorderStatus,
-  previousStatus: AudioRecorderStatus
-) => void;
-
 export interface IAudioRecorder {
   start: () => void;
   stop: () => void;
 
-  onAudioReady: (callback: IAudioReadyCallback) => void;
-  onError: (callback: IErrorCallback) => void;
-  onStatusChange: (callback: IStatusChangeCallback) => void;
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onAudioReady: string;
+}
+
+export interface IAudioEventEmitter {
+  addAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    callback: AudioEventCallback<Name>
+  ): string;
+  removeAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    subscriptionId: string
+  ): void;
 }

package/src/specs/NativeAudioAPIModule.ts

@@ -1,7 +1,28 @@
-import { TurboModuleRegistry, TurboModule } from 'react-native';
+'use strict';
+import { TurboModuleRegistry } from 'react-native';
+import type { TurboModule } from 'react-native';
+import { PermissionStatus } from '../system/types';
 
 interface Spec extends TurboModule {
   install(): boolean;
+
+  setLockScreenInfo(info: {
+    [key: string]: string | boolean | number | undefined;
+  }): void;
+  resetLockScreenInfo(): void;
+  enableRemoteCommand(name: string, enabled: boolean): void;
+  setAudioSessionOptions(
+    category: string,
+    mode: string,
+    options: Array<string>
+  ): void;
+  getDevicePreferredSampleRate(): number;
+  observeAudioInterruptions(enabled: boolean): void;
+  observeVolumeChanges(enabled: boolean): void;
+  requestRecordingPermissions(): Promise<PermissionStatus>;
+  checkRecordingPermissions(): Promise<PermissionStatus>;
 }
 
-export default TurboModuleRegistry.get<Spec>('AudioAPIModule');
+const NativeAudioAPIModule = TurboModuleRegistry.get<Spec>('AudioAPIModule');
+
+export { NativeAudioAPIModule };

package/src/specs/index.ts

@@ -1,6 +1,4 @@
 'use strict';
+import { NativeAudioAPIModule } from './NativeAudioAPIModule';
 
-import NativeAudioAPIModule from './NativeAudioAPIModule';
-import { AudioManagerModule, eventEmitter } from './NativeAudioManagerModule';
-
-export { NativeAudioAPIModule, AudioManagerModule, eventEmitter };
+export { NativeAudioAPIModule };

package/src/system/AudioManager.ts

@@ -1,25 +1,34 @@
-import {
-  SessionOptions,
-  LockScreenInfo,
-  RemoteEventName,
-  RemoteEventCallback,
-  RemoteCommandName,
-  PermissionStatus,
-} from './types';
-import { AudioManagerModule, eventEmitter } from '../specs';
-import { EmitterSubscription } from 'react-native';
+import { SessionOptions, LockScreenInfo, PermissionStatus } from './types';
+import { SystemEventName, SystemEventCallback } from '../events/types';
+import { NativeAudioAPIModule } from '../specs';
+import { AudioEventEmitter, AudioEventSubscription } from '../events';
+
+if (global.AudioEventEmitter == null) {
+  if (!NativeAudioAPIModule) {
+    throw new Error(
+      `Failed to install react-native-audio-api: The native module could not be found.`
+    );
+  }
+
+  NativeAudioAPIModule.install();
+}
 
 class AudioManager {
+  private readonly audioEventEmitter: AudioEventEmitter;
+  constructor() {
+    this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
+  }
+
   setLockScreenInfo(info: LockScreenInfo) {
-    AudioManagerModule.setLockScreenInfo(info);
+    NativeAudioAPIModule!.setLockScreenInfo(info);
   }
 
   resetLockScreenInfo() {
-    AudioManagerModule.resetLockScreenInfo();
+    NativeAudioAPIModule!.resetLockScreenInfo();
   }
 
   setAudioSessionOptions(options: SessionOptions) {
-    AudioManagerModule.setAudioSessionOptions(
+    NativeAudioAPIModule!.setAudioSessionOptions(
       options.iosCategory ?? '',
       options.iosMode ?? '',
       options.iosOptions ?? []
@@ -27,54 +36,37 @@ class AudioManager {
   }
 
   getDevicePreferredSampleRate(): number {
-    return AudioManagerModule.getDevicePreferredSampleRate();
+    return NativeAudioAPIModule!.getDevicePreferredSampleRate();
   }
 
   observeAudioInterruptions(enabled: boolean) {
-    AudioManagerModule.observeAudioInterruptions(enabled);
+    NativeAudioAPIModule!.observeAudioInterruptions(enabled);
   }
 
   observeVolumeChanges(enabled: boolean) {
-    AudioManagerModule.observeVolumeChanges(enabled);
+    NativeAudioAPIModule!.observeVolumeChanges(enabled);
   }
 
-  enableRemoteCommand<Name extends RemoteCommandName>(name: Name): void {
-    AudioManagerModule.enableRemoteCommand(name, true);
-  }
-
-  enableRemoteEvent<Name extends RemoteEventName>(
+  enableSystemEvent<Name extends SystemEventName>(
     name: Name,
-    callback?: RemoteEventCallback<Name>
-  ): EmitterSubscription | null {
-    let subscription = null;
-    if (!callback) {
+    callback?: SystemEventCallback<Name>,
+    enabled = true
+  ): AudioEventSubscription | null {
+    NativeAudioAPIModule!.enableRemoteCommand(name, enabled);
+
+    if (!enabled || !callback) {
       return null;
     }
-    switch (name) {
-      case 'interruption':
-        subscription = eventEmitter.addListener('onInterruption', callback);
-        break;
 
-      case 'routeChange':
-        subscription = eventEmitter.addListener('onRouteChange', callback);
-        break;
-
-      case 'volumeChange':
-        subscription = eventEmitter.addListener('onVolumeChange', callback);
-        break;
-
-      default:
-        console.error('Unsupported RemoteControl action:', name);
-    }
-    return subscription;
+    return this.audioEventEmitter.addAudioEventListener(name, callback);
   }
 
   async requestRecordingPermissions(): Promise<PermissionStatus> {
-    return AudioManagerModule.requestRecordingPermissions();
+    return NativeAudioAPIModule!.requestRecordingPermissions();
   }
 
   async checkRecordingPermissions(): Promise<PermissionStatus> {
-    return AudioManagerModule.checkRecordingPermissions();
+    return NativeAudioAPIModule!.checkRecordingPermissions();
   }
 }
 

package/src/system/types.ts

@@ -51,46 +51,4 @@ export interface LockScreenInfo extends BaseLockScreenInfo {
   elapsedTime?: number;
 }
 
-interface RemoteEmptyType {}
-
-interface RemoteControlEventType {
-  value: number;
-}
-
-interface OnInterruptionEventType {
-  type: 'ended' | 'began';
-  shouldResume: boolean;
-}
-
-interface OnRouteChangeEventType {
-  reason: string;
-}
-
-interface RemoteCommands {
-  play: RemoteEmptyType;
-  pause: RemoteEmptyType;
-  stop: RemoteEmptyType;
-  togglePlayPause: RemoteEmptyType;
-  changePlaybackRate: RemoteEmptyType;
-  nextTrack: RemoteEmptyType;
-  previousTrack: RemoteEmptyType;
-  skipForward: RemoteEmptyType;
-  skipBackward: RemoteEmptyType;
-  seekForward: RemoteEmptyType;
-  seekBackward: RemoteEmptyType;
-  changePlaybackPosition: RemoteEmptyType;
-}
-
-interface RemoteEvents {
-  volumeChange: RemoteControlEventType;
-  interruption: OnInterruptionEventType;
-  routeChange: OnRouteChangeEventType;
-}
-
-export type RemoteCommandName = keyof RemoteCommands;
-export type RemoteEventName = keyof RemoteEvents;
-export type RemoteEventCallback<Name extends RemoteEventName> = (
-  event: RemoteEvents[Name]
-) => void;
-
 export type PermissionStatus = 'Undetermined' | 'Denied' | 'Granted';

package/src/types.ts

@@ -45,11 +45,3 @@ export type WindowType = 'blackman' | 'hann';
 export interface AudioBufferSourceNodeOptions {
   pitchCorrection: boolean;
 }
-
-export type AudioRecorderStatus =
-  | 'idle'
-  | 'initializing'
-  | 'ready'
-  | 'running'
-  | 'stopping'
-  | 'error';