react-native-audio-api 0.11.0-alpha.0 → 0.11.0-nightly-bfab178-20251107

package/src/interfaces.ts

@@ -1,5 +1,5 @@
 import { AudioEventCallback, AudioEventName } from './events/types';
-import type {
+import {
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
@@ -8,6 +8,8 @@ import type {
   WindowType,
 } from './types';
 
+// IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer
+
 export type WorkletNodeCallback = (
   audioData: Array<ArrayBuffer>,
   channelCount: number
@@ -75,6 +77,10 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
+  createConvolver: (
+    buffer: IAudioBuffer | undefined,
+    disableNormalization: boolean
+  ) => IConvolverNode;
   createStreamer: () => IStreamerNode;
 }
 
@@ -184,6 +190,11 @@ export interface IAudioBufferQueueSourceNode
   pause: () => void;
 }
 
+export interface IConvolverNode extends IAudioNode {
+  buffer: IAudioBuffer | null;
+  normalize: boolean;
+}
+
 export interface IAudioBuffer {
   readonly length: number;
   readonly duration: number;
@@ -250,57 +261,14 @@ export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
 
 export interface IWorkletProcessingNode extends IAudioNode {}
 
-type IOSAudioRecorderFileDescriptor = number;
-type AndroidAudioRecorderFileDescriptor = number;
-
-interface IAudioRecorderFileOptions {
-  sampleRate: number;
-  channels: number;
-  bitRate: number;
-  /**
-   * IOS specific file recording options
-   *
-   * - `format` - IOSFormat, bitmask 0 x 0000000F
-   * - `quality` - IOSAudioQuality, bitmask 0 x 000000F0
-   * - `flacCompressionLevel` - FlacCompressionLevel, bitmask 0 x 00000F00
-   * - `directory` - FileDirectory, bitmask 0 x 0000F000
-   * - `bitDepth` - BitDepth, bitmask 0 x 000F0000
-   */
-  ios: IOSAudioRecorderFileDescriptor;
-  /**
-   * Android specific file recording options
-   *
-   * - He he
-   */
-  android: AndroidAudioRecorderFileDescriptor;
-}
-
-interface IAudioRecorderCallbackOptions {
-  sampleRate: number;
-  bufferLength: number;
-  channelCount: number;
-  callbackId: string;
-}
-
 export interface IAudioRecorder {
-  // default recorder methods
   start: () => void;
-  stop: () => string | void;
-  isRecording: () => boolean;
-
-  enableFileOutput: (options: IAudioRecorderFileOptions) => void;
-  disableFileOutput: () => void;
-
-  // pause and resume methods for file recording
-  pause: () => void;
-  resume: () => void;
-
-  // Graph integration methods
+  stop: () => void;
   connect: (node: IRecorderAdapterNode) => void;
   disconnect: () => void;
 
-  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => void;
-  clearOnAudioReady: () => void;
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onAudioReady: string;
 }
 
 export interface IAudioDecoder {

package/src/specs/NativeAudioAPIModule.ts

@@ -15,6 +15,7 @@ interface Spec extends TurboModule {
     options: Array<string>,
     allowHaptics: boolean
   ): void;
+  disableSessionManagement(): void;
 
   // Lock Screen Info
   setLockScreenInfo(info: {

package/src/system/AudioManager.ts

@@ -45,6 +45,10 @@ class AudioManager {
     );
   }
 
+  disableSessionManagement() {
+    NativeAudioAPIModule!.disableSessionManagement();
+  }
+
   setLockScreenInfo(info: LockScreenInfo) {
     NativeAudioAPIModule!.setLockScreenInfo(info);
   }

package/src/types.ts

@@ -1,3 +1,5 @@
+import AudioBuffer from './core/AudioBuffer';
+
 export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
 
 export type ChannelInterpretation = 'speakers' | 'discrete';
@@ -12,7 +14,7 @@ export type BiquadFilterType =
   | 'notch'
   | 'allpass';
 
-export type ContextState = 'running' | 'closed' | 'suspended';
+export type ContextState = 'running' | 'closed' | `suspended`;
 
 export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
 
@@ -38,69 +40,9 @@ export interface OfflineAudioContextOptions {
   sampleRate: number;
 }
 
-export enum FileDirectory {
-  Document = 1,
-  Cache = 2,
-}
-
-export enum IOSFormat {
-  Wav = 1,
-  Caf = 2,
-  M4A = 3,
-  Flac = 4,
-}
-
-export enum IOSAudioQuality {
-  Min = 1,
-  Low = 2,
-  Medium = 3,
-  High = 4,
-  Max = 5,
-}
-
-export enum AndroidFormat {
-  Wav = 1,
-  Caf = 2,
-  M4A = 3,
-  Flac = 4,
-}
-
-export enum FlacCompressionLevel {
-  L0 = 1,
-  L1 = 2,
-  L2 = 3,
-  L3 = 4,
-  L4 = 5,
-  L5 = 6,
-  L6 = 7,
-  L7 = 8,
-  L8 = 9,
-}
-
-export enum BitDepth {
-  Bit16 = 1,
-  Bit24 = 2,
-  Bit32 = 3,
-}
-
-export interface AudioRecorderFileOptionsIOS {
-  format?: IOSFormat;
-  quality?: IOSAudioQuality;
-  flacCompressionLevel?: FlacCompressionLevel;
-}
-
-export interface AudioRecorderFileOptionsAndroid {
-  format?: AndroidFormat;
-}
-
-export interface AudioRecorderFileOptions {
-  directory?: FileDirectory;
-  sampleRate?: number;
-  channels?: number;
-  bitRate?: number;
-  bitDepth?: BitDepth;
-  ios?: AudioRecorderFileOptionsIOS;
-  android?: AudioRecorderFileOptionsAndroid;
+export interface AudioRecorderOptions {
+  sampleRate: number;
+  bufferLengthInSamples: number;
 }
 
 export type WindowType = 'blackman' | 'hann';
@@ -111,24 +53,7 @@ export interface AudioBufferBaseSourceNodeOptions {
 
 export type ProcessorMode = 'processInPlace' | 'processThrough';
 
-export interface AudioRecorderCallbackOptions {
-  /**
-   * The desired sample rate (in Hz) for audio buffers delivered to the
-   * recording callback. Common values include 44100 or 48000 Hz. The actual
-   * sample rate may differ depending on hardware and system capabilities.
-   */
-  sampleRate: number;
-
-  /**
-   * The preferred size of each audio buffer, expressed as the number of samples
-   * per channel. Smaller buffers reduce latency but increase CPU load, while
-   * larger buffers improve efficiency at the cost of higher latency.
-   */
-  bufferLength: number;
-
-  /**
-   * The desired number of audio channels per buffer. Typically 1 for mono or 2
-   * for stereo recordings.
-   */
-  channelCount: number;
+export interface ConvolverNodeOptions {
+  buffer?: AudioBuffer | null;
+  disableNormalization?: boolean;
 }

package/src/utils/index.ts

@@ -1,5 +1,4 @@
 import type { ShareableWorkletCallback } from '../interfaces';
-export * from './bitEnums';
 
 interface SimplifiedWorkletModule {
   makeShareableCloneRecursive: (
@@ -14,12 +13,33 @@ export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
 
-export let isWorkletsAvailable = false;
+let isWorkletsAvailable = false;
+export let isWorkletsVersionSupported = false;
+export let workletsVersion = 'unknown';
+export const supportedWorkletsVersions = ['0.6.0', '0.6.1'];
 export let workletsModule: SimplifiedWorkletModule;
 
+export function assertWorkletsEnabled() {
+  if (!isWorkletsAvailable) {
+    throw new Error(
+      '[react-native-audio-api]: Worklets are not available. Please install react-native-worklets to use this feature.'
+    );
+  } else if (!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.`
+    );
+  }
+}
+
 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;

package/src/web-core/AudioContext.tsx

@@ -15,6 +15,8 @@ import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import ConvolverNode from './ConvolverNode';
+import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConstantSourceNode from './ConstantSourceNode';
@@ -70,6 +72,29 @@ export default class AudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
+  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

@@ -9,6 +9,7 @@ import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
+import ConvolverNode from './ConvolverNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -23,6 +24,7 @@ export default interface BaseAudioContext {
   createGain(): GainNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
+  createConvolver(): ConvolverNode;
   createBufferSource(): Promise<AudioBufferSourceNode>;
   createBuffer(
     numOfChannels: number,

package/src/web-core/ConvolverNode.tsx

@@ -0,0 +1,43 @@
+import BaseAudioContext from './BaseAudioContext';
+import AudioNode from './AudioNode';
+import AudioBuffer from './AudioBuffer';
+
+export default class ConvolverNode extends AudioNode {
+  constructor(
+    context: BaseAudioContext,
+    node: globalThis.ConvolverNode,
+    buffer: AudioBuffer | null = null,
+    disableNormalization: boolean = false
+  ) {
+    super(context, node);
+
+    (this.node as globalThis.ConvolverNode).normalize = !disableNormalization;
+    if (buffer) {
+      (this.node as globalThis.ConvolverNode).buffer = buffer.buffer;
+    }
+  }
+
+  public get buffer(): AudioBuffer | null {
+    const buffer = (this.node as globalThis.ConvolverNode).buffer;
+    if (!buffer) {
+      return null;
+    }
+    return new AudioBuffer(buffer);
+  }
+
+  public set buffer(buffer: AudioBuffer | null) {
+    if (!buffer) {
+      (this.node as globalThis.ConvolverNode).buffer = null;
+    } else {
+      (this.node as globalThis.ConvolverNode).buffer = buffer.buffer;
+    }
+  }
+
+  public get normalize(): boolean {
+    return (this.node as globalThis.ConvolverNode).normalize;
+  }
+
+  public set normalize(value: boolean) {
+    (this.node as globalThis.ConvolverNode).normalize = value;
+  }
+}

package/src/web-core/ConvolverNodeOptions.tsx

@@ -0,0 +1,6 @@
+import AudioBuffer from './AudioBuffer';
+
+export interface ConvolverNodeOptions {
+  buffer?: AudioBuffer | null;
+  disableNormalization?: boolean;
+}

package/src/web-core/OfflineAudioContext.tsx

@@ -18,6 +18,8 @@ import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
+import ConvolverNode from './ConvolverNode';
+import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 
 export default class OfflineAudioContext implements BaseAudioContext {
   readonly context: globalThis.OfflineAudioContext;
@@ -76,6 +78,29 @@ export default class OfflineAudioContext implements BaseAudioContext {
     return new BiquadFilterNode(this, this.context.createBiquadFilter());
   }
 
+  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/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <string>
-#include <memory>
-
-namespace audioapi {
-
-class AndroidFileWriterBackend {
- public:
-  AndroidFileWriterBackend(
-    float sampleRate,
-    size_t channelCount,
-    size_t bitRate,
-    size_t androidFlags) {}
-
-  virtual ~AndroidFileWriterBackend() = default;
-
-  virtual void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
-  virtual std::string closeFile() = 0;
-
-  virtual bool writeAudioData(void *data, int numFrames) = 0;
-
-  std::string getFilePath() const { return filePath_; }
-
- protected:
-  std::string filePath_{""};
-
-  int32_t streamSampleRate_{0};
-  int32_t streamChannelCount_{0};
-  int32_t streamMaxBufferSize_{0};
-};
-
-} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/utils/FileUtils.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace audioapi::android::fileutils {
-
-enum class FileDirectory {
-  FILES_DIR,
-  CACHE_DIR,
-};
-
-enum class FileFormat {
-  WAV,
-  CAF,
-  M4A,
-  FLAC,
-};
-
-enum class BitDepth {
-  BIT_16,
-  BIT_24,
-  BIT_32,
-};
-
-bool createDirectoryIfNotExists(const std::string &directoryPath);
-std::string getTimestampString();
-std::string getISODateString();
-FileFormat formatFromFlags(size_t flags);
-FileDirectory directoryFromFlags(size_t flags);
-BitDepth bitDepthFromFlags(size_t flags);
-std::string getDirectory(FileDirectory dir);
-std::string getFilePath(const FileDirectory &directory, const std::string &baseFileName, const std::string &extension);
-
-} // namespace audioapi::android::fileutils

package/android/src/main/cpp/audioapi/android/core/utils/FileUtilts.cpp

@@ -1,133 +0,0 @@
-
-#include <android/log.h>
-#include <audioapi/android/core/utils/FileUtils.h>
-#include <audioapi/android/system/NativeFileInfo.hpp>
-#include <chrono>
-#include <filesystem>
-#include <format>
-#include <iostream>
-
-namespace audioapi::android::fileutils {
-
-bool createDirectoryIfNotExists(const std::string &directoryPath) {
-  std::error_code ec;
-
-  if (!std::filesystem::exists(directoryPath, ec)) {
-    bool created = std::filesystem::create_directories(directoryPath, ec);
-
-    if (ec) {
-      __android_log_print(
-          ANDROID_LOG_ERROR,
-          "FileUtils",
-          "Error creating directory at path: %s, error: %s",
-          directoryPath.c_str(),
-          ec.message().c_str());
-
-      return false;
-    }
-
-    return created;
-  }
-
-  if (ec) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "FileUtils",
-        "Error checking existence of directory at path: %s, error: %s",
-        directoryPath.c_str(),
-        ec.message().c_str());
-
-    return false;
-  }
-
-  return true;
-}
-
-std::string getTimestampString() {
-  auto tNow = std::chrono::system_clock::now();
-  return std::format(
-      "{:%Y%m%d_%H%M%S}", std::chrono::floor<std::chrono::seconds>(tNow));
-}
-
-std::string getISODateString() {
-  auto tNow = std::chrono::system_clock::now();
-  return std::format(
-      "{:%Y-%m-%d}", std::chrono::floor<std::chrono::days>(tNow));
-}
-
-FileFormat formatFromFlags(size_t flags) {
-  uint8_t formatFlag = static_cast<uint8_t>(flags & 0xF);
-
-  switch (formatFlag) {
-    case 1:
-      return FileFormat::WAV;
-    case 2:
-      return FileFormat::CAF;
-    case 3:
-      return FileFormat::M4A;
-    case 4:
-      return FileFormat::FLAC;
-    default:
-      return FileFormat::M4A;
-  }
-}
-
-FileDirectory directoryFromFlags(size_t flags) {
-  uint8_t directoryFlag = static_cast<uint8_t>((flags >> 4) & 0xF);
-
-  switch (directoryFlag) {
-    case 1:
-      return FileDirectory::FILES_DIR;
-    case 2:
-      return FileDirectory::CACHE_DIR;
-    default:
-      return FileDirectory::CACHE_DIR;
-  }
-}
-
-BitDepth bitDepthFromFlags(size_t flags) {
-  uint8_t bitDepthFlag = static_cast<uint8_t>((flags >> 8) & 0xF);
-
-  switch (bitDepthFlag) {
-    case 1:
-      return BitDepth::BIT_16;
-    case 2:
-      return BitDepth::BIT_24;
-    case 3:
-      return BitDepth::BIT_32;
-    default:
-      return BitDepth::BIT_32;
-  }
-}
-
-std::string getDirectory(FileDirectory dir) {
-  switch (dir) {
-    case FileDirectory::FILES_DIR:
-      return NativeFileInfo::getFilesDir();
-    case FileDirectory::CACHE_DIR:
-      return NativeFileInfo::getCacheDir();
-    default:
-      return NativeFileInfo::getCacheDir();
-  }
-}
-
-std::string getFilePath(
-    const FileDirectory &directory,
-    const std::string &baseFileName,
-    const std::string &extension) {
-  std::string basePath = getDirectory(directory);
-  std::string subDirectory = getISODateString();
-  std::string fileTimestamp = getTimestampString();
-
-  std::string subDirectoryPath =
-      std::format("{}/AudioAPI/{}", basePath, subDirectory);
-
-  if (!createDirectoryIfNotExists(subDirectoryPath)) {
-    return "";
-  }
-
-  return std::format(
-      "{}/{}_{}.{}", subDirectoryPath, baseFileName, fileTimestamp, extension);
-}
-
-} // namespace audioapi::android::fileutils

package/android/src/main/cpp/audioapi/android/core/utils/MiniaudioImplementation.cpp

@@ -1,3 +0,0 @@
-#define MINIAUDIO_IMPLEMENTATION
-#define MA_DEBUG_OUTPUT
-#include <audioapi/libs/miniaudio/miniaudio.h>