react-native-audio-api 0.10.0 → 0.10.2

package/src/core/BaseAudioContext.ts

@@ -1,23 +1,23 @@
+import AudioAPIModule from '../AudioAPIModule';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import { IBaseAudioContext } from '../interfaces';
 import {
   AudioBufferBaseSourceNodeOptions,
-  ContextState,
-  PeriodicWaveConstraints,
   AudioWorkletRuntime,
+  ContextState,
   ConvolverNodeOptions,
+  PeriodicWaveConstraints,
 } from '../types';
-import { assertWorkletsEnabled, workletsModule } from '../utils';
-import WorkletSourceNode from './WorkletSourceNode';
-import WorkletProcessingNode from './WorkletProcessingNode';
+import { assertWorkletsEnabled } from '../utils';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
-import ConvolverNode from './ConvolverNode';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
+import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 import AudioDestinationNode from './AudioDestinationNode';
 import BiquadFilterNode from './BiquadFilterNode';
 import ConstantSourceNode from './ConstantSourceNode';
+import ConvolverNode from './ConvolverNode';
 import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
@@ -25,7 +25,8 @@ import RecorderAdapterNode from './RecorderAdapterNode';
 import StereoPannerNode from './StereoPannerNode';
 import StreamerNode from './StreamerNode';
 import WorkletNode from './WorkletNode';
-import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
+import WorkletProcessingNode from './WorkletProcessingNode';
+import WorkletSourceNode from './WorkletSourceNode';
 
 export default class BaseAudioContext {
   readonly destination: AudioDestinationNode;
@@ -81,21 +82,26 @@ export default class BaseAudioContext {
         `The number of input channels provided (${inputChannelCount}) can not be less than 1 or greater than 32`
       );
     }
+
     if (bufferLength < 1) {
       throw new NotSupportedError(
         `The buffer length provided (${bufferLength}) can not be less than 1`
       );
     }
+
     assertWorkletsEnabled();
-    const shareableWorklet = workletsModule.makeShareableCloneRecursive(
-      (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
-        'worklet';
-        const floatAudioData: Array<Float32Array> = audioBuffers.map(
-          (buffer) => new Float32Array(buffer)
-        );
-        callback(floatAudioData, channelCount);
-      }
-    );
+
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
+          'worklet';
+          const floatAudioData: Array<Float32Array> = audioBuffers.map(
+            (buffer) => new Float32Array(buffer)
+          );
+          callback(floatAudioData, channelCount);
+        }
+      );
+
     return new WorkletNode(
       this,
       this.context.createWorkletNode(
@@ -117,23 +123,26 @@ export default class BaseAudioContext {
     workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
   ): WorkletProcessingNode {
     assertWorkletsEnabled();
-    const shareableWorklet = 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 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);
+        }
+      );
+
     return new WorkletProcessingNode(
       this,
       this.context.createWorkletProcessingNode(
@@ -153,20 +162,22 @@ export default class BaseAudioContext {
     workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
   ): WorkletSourceNode {
     assertWorkletsEnabled();
-    const shareableWorklet = 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 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);
+        }
+      );
+
     return new WorkletSourceNode(
       this,
       this.context.createWorkletSourceNode(

package/src/core/OfflineAudioContext.ts

@@ -1,9 +1,9 @@
+import AudioAPIModule from '../AudioAPIModule';
+import { InvalidStateError, NotSupportedError } from '../errors';
 import { IOfflineAudioContext } from '../interfaces';
-import BaseAudioContext from './BaseAudioContext';
 import { OfflineAudioContextOptions } from '../types';
-import { InvalidStateError, NotSupportedError } from '../errors';
 import AudioBuffer from './AudioBuffer';
-import { isWorkletsVersionSupported, workletsModule } from '../utils';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class OfflineAudioContext extends BaseAudioContext {
   private isSuspended: boolean;
@@ -17,10 +17,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
     arg1?: number,
     arg2?: number
   ) {
-    let audioRuntime = null;
-    if (isWorkletsVersionSupported) {
-      audioRuntime = workletsModule.createWorkletRuntime('AudioWorkletRuntime');
-    }
+    const audioRuntime = AudioAPIModule.createAudioRuntime();
 
     if (typeof arg0 === 'object') {
       const { numberOfChannels, length, sampleRate } = arg0;

package/src/system/AudioManager.ts

@@ -1,26 +1,16 @@
+import { AudioEventEmitter, AudioEventSubscription } from '../events';
 import {
-  SessionOptions,
-  LockScreenInfo,
-  PermissionStatus,
-  AudioDevicesInfo,
-} from './types';
-import {
-  SystemEventName,
-  SystemEventCallback,
   RemoteCommandEventName,
+  SystemEventCallback,
+  SystemEventName,
 } 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();
-}
+import {
+  AudioDevicesInfo,
+  LockScreenInfo,
+  PermissionStatus,
+  SessionOptions,
+} from './types';
 
 class AudioManager {
   private readonly audioEventEmitter: AudioEventEmitter;

package/src/utils/index.ts

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