react-native-audio-api 0.11.0-nightly-b30bac9-20260114 → 0.11.0

package/src/core/AudioDecoder.ts

@@ -1,5 +1,14 @@
+import { Image } from 'react-native';
+
 import { IAudioDecoder } from '../interfaces';
+import { DecodeDataInput } from '../types';
+import {
+  isBase64Source,
+  isDataBlobString,
+  isRemoteSource,
+} from '../utils/paths';
 import AudioBuffer from './AudioBuffer';
+import { AudioApiError } from '../errors';
 
 class AudioDecoder {
   private static instance: AudioDecoder | null = null;
@@ -9,35 +18,91 @@ class AudioDecoder {
     this.decoder = global.createAudioDecoder();
   }
 
+  private async decodeAudioDataImplementation(
+    input: DecodeDataInput,
+    sampleRate?: number,
+    fetchOptions?: RequestInit
+  ): Promise<AudioBuffer | null | undefined> {
+    if (input instanceof ArrayBuffer) {
+      const buffer = await this.decoder.decodeWithMemoryBlock(
+        new Uint8Array(input),
+        sampleRate ?? 0
+      );
+      return new AudioBuffer(buffer);
+    }
+
+    const stringSource =
+      typeof input === 'number' ? Image.resolveAssetSource(input).uri : input;
+
+    // input is data:audio/...;base64,...
+    if (isBase64Source(stringSource)) {
+      throw new AudioApiError(
+        'Base64 source decoding is not currently supported, to decode raw PCM base64 strings use decodePCMInBase64 method.'
+      );
+    }
+
+    // input is blob:...
+    if (isDataBlobString(stringSource)) {
+      throw new AudioApiError(
+        'Data Blob string decoding is not currently supported.'
+      );
+    }
+
+    // input is http(s)://...
+    if (isRemoteSource(stringSource)) {
+      const arrayBuffer = await fetch(stringSource, fetchOptions).then((res) =>
+        res.arrayBuffer()
+      );
+
+      const buffer = await this.decoder.decodeWithMemoryBlock(
+        new Uint8Array(arrayBuffer),
+        sampleRate ?? 0
+      );
+
+      return new AudioBuffer(buffer);
+    }
+
+    if (!(typeof input === 'string')) {
+      throw new TypeError('Input must be a module, uri or ArrayBuffer');
+    }
+
+    // Local file path
+    const filePath = stringSource.startsWith('file://')
+      ? stringSource.replace('file://', '')
+      : stringSource;
+
+    const buffer = await this.decoder.decodeWithFilePath(
+      filePath,
+      sampleRate ?? 0
+    );
+
+    return new AudioBuffer(buffer);
+  }
+
   public static getInstance(): AudioDecoder {
     if (!AudioDecoder.instance) {
       AudioDecoder.instance = new AudioDecoder();
     }
+
     return AudioDecoder.instance;
   }
 
   public async decodeAudioDataInstance(
-    input: string | ArrayBuffer,
-    sampleRate?: number
+    input: DecodeDataInput,
+    sampleRate?: number,
+    fetchOptions?: RequestInit
   ): Promise<AudioBuffer> {
-    let buffer;
-    if (typeof input === 'string') {
-      // Remove the file:// prefix if it exists
-      if (input.startsWith('file://')) {
-        input = input.replace('file://', '');
-      }
-      buffer = await this.decoder.decodeWithFilePath(input, sampleRate ?? 0);
-    } else if (input instanceof ArrayBuffer) {
-      buffer = await this.decoder.decodeWithMemoryBlock(
-        new Uint8Array(input),
-        sampleRate ?? 0
-      );
-    }
+    const audioBuffer = await this.decodeAudioDataImplementation(
+      input,
+      sampleRate,
+      fetchOptions
+    );
 
-    if (!buffer) {
-      throw new Error('Unsupported input type or failed to decode audio');
+    if (!audioBuffer) {
+      throw new AudioApiError('Failed to decode audio data.');
     }
-    return new AudioBuffer(buffer);
+
+    return audioBuffer;
   }
 
   public async decodePCMInBase64Instance(
@@ -57,10 +122,15 @@ class AudioDecoder {
 }
 
 export async function decodeAudioData(
-  input: string | ArrayBuffer,
-  sampleRate?: number
+  input: DecodeDataInput,
+  sampleRate?: number,
+  fetchOptions?: RequestInit
 ): Promise<AudioBuffer> {
-  return AudioDecoder.getInstance().decodeAudioDataInstance(input, sampleRate);
+  return AudioDecoder.getInstance().decodeAudioDataInstance(
+    input,
+    sampleRate,
+    fetchOptions
+  );
 }
 
 export async function decodePCMInBase64(

package/src/core/AudioRecorder.ts

@@ -15,6 +15,7 @@ import {
 import FilePreset from '../utils/filePresets';
 import AudioBuffer from './AudioBuffer';
 import RecorderAdapterNode from './RecorderAdapterNode';
+import { AudioApiError } from '../errors';
 
 // Enforces default options, making sure that all properties are defined
 // for the contract with native code.
@@ -107,7 +108,7 @@ export default class AudioRecorder {
    */
   connect(node: RecorderAdapterNode): void {
     if (node.wasConnected) {
-      throw new Error(
+      throw new AudioApiError(
         'RecorderAdapterNode cannot be connected more than once. Refer to the documentation for more details.'
       );
     }

package/src/core/AudioStretcher.ts

@@ -1,5 +1,6 @@
 import { IAudioStretcher } from '../interfaces';
 import AudioBuffer from './AudioBuffer';
+import { AudioApiError } from '../errors';
 
 class AudioStretcher {
   private static instance: AudioStretcher | null = null;
@@ -26,7 +27,7 @@ class AudioStretcher {
     );
 
     if (!buffer) {
-      throw new Error('Failed to change playback speed');
+      throw new AudioApiError('Failed to change playback speed');
     }
     return new AudioBuffer(buffer);
   }

package/src/core/BaseAudioContext.ts

@@ -10,6 +10,7 @@ import {
   AudioWorkletRuntime,
   ContextState,
   ConvolverNodeOptions,
+  DecodeDataInput,
   IIRFilterNodeOptions,
   PeriodicWaveConstraints,
 } from '../types';
@@ -56,13 +57,10 @@ export default class BaseAudioContext {
   }
 
   public async decodeAudioData(
-    input: string | ArrayBuffer,
-    sampleRate?: number
+    input: DecodeDataInput,
+    fetchOptions?: RequestInit
   ): Promise<AudioBuffer> {
-    if (!(typeof input === 'string' || input instanceof ArrayBuffer)) {
-      throw new TypeError('Input must be a string or ArrayBuffer');
-    }
-    return await decodeAudioData(input, sampleRate ?? this.sampleRate);
+    return await decodeAudioData(input, this.sampleRate, fetchOptions);
   }
 
   public async decodePCMInBase64(

package/src/errors/AudioApiError.ts

@@ -0,0 +1,8 @@
+class AudioApiError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AudioApiError';
+  }
+}
+
+export default AudioApiError;

package/src/errors/index.ts

@@ -3,3 +3,4 @@ export { default as InvalidAccessError } from './InvalidAccessError';
 export { default as InvalidStateError } from './InvalidStateError';
 export { default as RangeError } from './RangeError';
 export { default as NotSupportedError } from './NotSupportedError';
+export { default as AudioApiError } from './AudioApiError';

package/src/interfaces.ts

@@ -8,9 +8,9 @@ import type {
   ContextState,
   FileInfo,
   OscillatorType,
+  OverSampleType,
   Result,
   WindowType,
-  OverSampleType,
 } from './types';
 
 // IMPORTANT: use only IClass, because it is a part of contract between cpp host object and js layer

package/src/specs/NativeAudioAPIModule.ts

@@ -1,11 +1,9 @@
 'use strict';
-
-import { TurboModuleRegistry, TurboModule } from 'react-native';
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } 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';
 
@@ -37,21 +35,13 @@ interface Spec extends TurboModule {
   // Audio devices
   getDevicesInfo(): Promise<AudioDevicesInfo>;
 
-  // New notification system
-  registerNotification(
-    type: NotificationType,
-    key: string
-  ): Promise<NotificationOpResponse>;
+  // Notification system
   showNotification(
-    key: string,
-    options: OptionsMap
-  ): Promise<NotificationOpResponse>;
-  updateNotification(
+    type: NotificationType,
     key: string,
     options: OptionsMap
   ): Promise<NotificationOpResponse>;
   hideNotification(key: string): Promise<NotificationOpResponse>;
-  unregisterNotification(key: string): Promise<NotificationOpResponse>;
   isNotificationActive(key: string): Promise<boolean>;
 }
 

package/src/specs/NativeAudioAPIModule.web.ts

@@ -37,20 +37,12 @@ interface Spec extends TurboModule {
   getDevicesInfo(): Promise<AudioDevicesInfo>;
 
   // New notification system
-  registerNotification(
-    type: NotificationType,
-    key: string
-  ): Promise<NotificationOpResponse>;
   showNotification(
-    key: string,
-    options: OptionsMap
-  ): Promise<NotificationOpResponse>;
-  updateNotification(
+    type: NotificationType,
     key: string,
     options: OptionsMap
   ): Promise<NotificationOpResponse>;
   hideNotification(key: string): Promise<NotificationOpResponse>;
-  unregisterNotification(key: string): Promise<NotificationOpResponse>;
   isNotificationActive(key: string): Promise<boolean>;
 }
 
@@ -82,11 +74,8 @@ const NativeAudioAPIModule: Spec = {
     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),
 };
 

package/src/system/notification/PlaybackNotificationManager.ts

@@ -7,101 +7,50 @@ import type {
   PlaybackNotificationEventName,
   PlaybackNotificationInfo,
 } from './types';
+import { AudioApiError } from '../../errors';
 
-/// Manager for media playback notifications with controls and MediaSession integration.
 class PlaybackNotificationManager
   implements
-    NotificationManager<
-      PlaybackNotificationInfo,
-      PlaybackNotificationInfo,
-      PlaybackNotificationEventName
-    >
+    NotificationManager<PlaybackNotificationInfo, PlaybackNotificationEventName>
 {
   private notificationKey = 'playback';
-  private isRegistered_ = false;
-  private isShown_ = false;
   private audioEventEmitter: AudioEventEmitter;
 
   constructor() {
     this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
   }
 
-  /// Register the playback notification (must be called before showing).
-  async register(): Promise<void> {
-    if (this.isRegistered_) {
-      console.warn('PlaybackNotification is already registered');
-      return;
-    }
-
-    if (!NativeAudioAPIModule) {
-      throw new Error('NativeAudioAPIModule is not available');
-    }
-
-    const result = await NativeAudioAPIModule.registerNotification(
-      'playback',
-      this.notificationKey
-    );
-
-    if (result.error) {
-      throw new Error(result.error);
-    }
-
-    this.isRegistered_ = true;
-  }
-
-  /// Show the notification with initial metadata.
+  /**
+   * Show the notification with metadata or update if already visible.
+   * Automatically creates the notification on first call.
+   *
+   * @param info - The info to be displayed.
+   * @returns Promise that resolves after creating notification.
+   */
   async show(info: PlaybackNotificationInfo): Promise<void> {
-    if (!this.isRegistered_) {
-      throw new Error(
-        'PlaybackNotification must be registered before showing. Call register() first.'
-      );
-    }
-
     if (!NativeAudioAPIModule) {
-      throw new Error('NativeAudioAPIModule is not available');
+      throw new AudioApiError('NativeAudioAPIModule is not available');
     }
 
     const result = await NativeAudioAPIModule.showNotification(
+      'playback',
       this.notificationKey,
       info as Record<string, string | number | boolean | undefined>
     );
 
     if (result.error) {
-      throw new Error(result.error);
-    }
-
-    this.isShown_ = true;
-  }
-
-  /// Update the notification with new metadata or state.
-  async update(info: PlaybackNotificationInfo): Promise<void> {
-    if (!this.isShown_) {
-      console.warn('PlaybackNotification is not shown. Call show() first.');
-      return;
-    }
-
-    if (!NativeAudioAPIModule) {
-      throw new Error('NativeAudioAPIModule is not available');
-    }
-
-    const result = await NativeAudioAPIModule.updateNotification(
-      this.notificationKey,
-      info as Record<string, string | number | boolean | undefined>
-    );
-
-    if (result.error) {
-      throw new Error(result.error);
+      throw new AudioApiError(result.error);
     }
   }
 
-  /// Hide the notification (can be shown again later).
+  /**
+   * Hide the notification.
+   *
+   * @returns Promise that resolves after hiding notification.
+   */
   async hide(): Promise<void> {
-    if (!this.isShown_) {
-      return;
-    }
-
     if (!NativeAudioAPIModule) {
-      throw new Error('NativeAudioAPIModule is not available');
+      throw new AudioApiError('NativeAudioAPIModule is not available');
     }
 
     const result = await NativeAudioAPIModule.hideNotification(
@@ -109,63 +58,42 @@ class PlaybackNotificationManager
     );
 
     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);
+      throw new AudioApiError(result.error);
     }
-
-    this.isRegistered_ = false;
   }
 
-  /// Enable or disable a specific playback control.
+  /**
+   * Enable or disable a specific playback control.
+   *
+   * @param control - The control to enable or disable on the notification.
+   * @param enabled - Whether to enable (true) or disable (false) the control.
+   * @returns Promise that resolves after showing modified notification.
+   */
   async enableControl(
     control: PlaybackControlName,
     enabled: boolean
   ): Promise<void> {
-    if (!this.isRegistered_) {
-      console.warn('PlaybackNotification is not registered');
-      return;
-    }
-
     if (!NativeAudioAPIModule) {
-      throw new Error('NativeAudioAPIModule is not available');
+      throw new AudioApiError('NativeAudioAPIModule is not available');
     }
 
     const params = { control, enabled };
-    const result = await NativeAudioAPIModule.updateNotification(
+    const result = await NativeAudioAPIModule.showNotification(
+      'playback',
       this.notificationKey,
       params as Record<string, string | number | boolean | undefined>
     );
 
     if (result.error) {
-      throw new Error(result.error);
+      throw new AudioApiError(result.error);
     }
   }
 
-  /// Check if the notification is currently active.
+  /**
+   * Check if the notification is currently active.
+   *
+   * @returns Promise that resolves to whether notification is active.
+   */
   async isActive(): Promise<boolean> {
     if (!NativeAudioAPIModule) {
       return false;
@@ -176,22 +104,19 @@ class PlaybackNotificationManager
     );
   }
 
-  isRegistered(): boolean {
-    return this.isRegistered_;
-  }
-
-  /// Add an event listener for notification actions.
+  /**
+   * Add an event listener for notification actions.
+   *
+   * @param eventName - The event name to listen for.
+   * @param callback - The callback to invoke on event.
+   * @returns Class that represents the subscription.
+   */
   addEventListener<T extends PlaybackNotificationEventName>(
     eventName: T,
     callback: (event: NotificationEvents[T]) => void
   ): AudioEventSubscription {
     return this.audioEventEmitter.addAudioEventListener(eventName, callback);
   }
-
-  /** Remove an event listener. */
-  removeEventListener(subscription: AudioEventSubscription): void {
-    subscription.remove();
-  }
 }
 
 export default new PlaybackNotificationManager();

package/src/system/notification/RecordingNotificationManager.ios.ts

@@ -0,0 +1,65 @@
+import { AudioEventEmitter, AudioEventSubscription } from '../../events';
+import type {
+  NotificationManager,
+  RecordingNotificationEvent,
+  RecordingNotificationEventName,
+  RecordingNotificationInfo,
+} from './types';
+
+class RecordingNotificationManager
+  implements
+    NotificationManager<
+      RecordingNotificationInfo,
+      RecordingNotificationEventName
+    >
+{
+  private audioEventEmitter: AudioEventEmitter;
+
+  constructor() {
+    this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
+    console.warn(
+      'RecordingNotificationManager is not implemented on iOS. Any calls to it will be no-ops.'
+    );
+  }
+
+  /**
+   * Show the notification with metadata or update if already visible.
+   *
+   * @param info - The info to be displayed.
+   * @returns Promise that resolves after creating notification.
+   */
+  async show(_info: RecordingNotificationInfo): Promise<void> {}
+
+  /**
+   * Hide the notification.
+   *
+   * @returns Promise that resolves after hiding notification.
+   */
+  async hide(): Promise<void> {}
+
+  /**
+   * Check if the notification is currently active.
+   *
+   * @returns Promise that resolves to whether notification is active.
+   */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async isActive(): Promise<boolean> {
+    return false;
+  }
+
+  /**
+   * Add an event listener for notification actions.
+   *
+   * @param eventName - The event name to listen for.
+   * @param callback - The callback to invoke on event.
+   * @returns Promise that resolves to whether notification is active.
+   */
+  addEventListener<T extends RecordingNotificationEventName>(
+    eventName: T,
+    callback: (event: RecordingNotificationEvent[T]) => void
+  ): AudioEventSubscription {
+    return this.audioEventEmitter.addAudioEventListener(eventName, callback);
+  }
+}
+
+export default new RecordingNotificationManager();