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

package/src/interfaces.ts

@@ -1,13 +1,19 @@
 import { AudioEventCallback, AudioEventName } from './events/types';
 import type {
+  AudioRecorderCallbackOptions,
+  AudioRecorderFileOptions,
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
   ContextState,
+  FileInfo,
   OscillatorType,
+  Result,
   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
@@ -58,8 +64,13 @@ export interface IBaseAudioContext {
   createOscillator(): IOscillatorNode;
   createConstantSource(): IConstantSourceNode;
   createGain(): IGainNode;
+  createDelay(maxDelayTime: number): IDelayNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
+  createIIRFilter: (
+    feedforward: number[],
+    feedback: number[]
+  ) => IIIRFilterNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
   createBufferQueueSource: (
     pitchCorrection: boolean
@@ -75,7 +86,11 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
-  createStreamer: () => IStreamerNode;
+  createConvolver: (
+    buffer: IAudioBuffer | undefined,
+    disableNormalization: boolean
+  ) => IConvolverNode;
+  createStreamer: () => IStreamerNode | null; // null when FFmpeg is not enabled
 }
 
 export interface IAudioContext extends IBaseAudioContext {
@@ -102,6 +117,11 @@ export interface IAudioNode {
   disconnect: (destination?: IAudioNode | IAudioParam) => void;
 }
 
+export interface IDelayNode extends IAudioNode {
+  readonly delayTime: IAudioParam;
+  maxDelayTime: number;
+}
+
 export interface IGainNode extends IAudioNode {
   readonly gain: IAudioParam;
 }
@@ -124,6 +144,14 @@ export interface IBiquadFilterNode extends IAudioNode {
   ): void;
 }
 
+export interface IIIRFilterNode extends IAudioNode {
+  getFrequencyResponse(
+    frequencyArray: Float32Array,
+    magResponseOutput: Float32Array,
+    phaseResponseOutput: Float32Array
+  ): void;
+}
+
 export interface IAudioDestinationNode extends IAudioNode {}
 
 export interface IAudioScheduledSourceNode extends IAudioNode {
@@ -138,6 +166,9 @@ export interface IAudioBufferBaseSourceNode extends IAudioScheduledSourceNode {
   detune: IAudioParam;
   playbackRate: IAudioParam;
 
+  getInputLatency: () => number;
+  getOutputLatency: () => number;
+
   // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
   onPositionChanged: string;
   // set how often the onPositionChanged event is called
@@ -181,9 +212,17 @@ export interface IAudioBufferQueueSourceNode
 
   // returns bufferId
   enqueueBuffer: (audioBuffer: IAudioBuffer) => string;
+  start: (when?: number, offset?: number) => void;
   pause: () => void;
 }
 
+export interface IConvolverNode extends IAudioNode {
+  readonly buffer: IAudioBuffer | null;
+  normalize: boolean;
+
+  setBuffer: (audioBuffer: IAudioBuffer | null) => void;
+}
+
 export interface IAudioBuffer {
   readonly length: number;
   readonly duration: number;
@@ -250,45 +289,21 @@ 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;
+export interface IAudioRecorderCallbackOptions
+  extends AudioRecorderCallbackOptions {
   callbackId: string;
 }
 
 export interface IAudioRecorder {
   // default recorder methods
-  start: () => void;
-  stop: () => string | void;
+  start: () => Result<{ path: string }>;
+  stop: () => Result<FileInfo>;
   isRecording: () => boolean;
+  isPaused: () => boolean;
 
-  enableFileOutput: (options: IAudioRecorderFileOptions) => void;
+  enableFileOutput: (
+    options: AudioRecorderFileOptions
+  ) => Result<{ path: string }>;
   disableFileOutput: () => void;
 
   // pause and resume methods for file recording
@@ -299,8 +314,14 @@ export interface IAudioRecorder {
   connect: (node: IRecorderAdapterNode) => void;
   disconnect: () => void;
 
-  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => void;
+  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => Result<void>;
   clearOnAudioReady: () => void;
+
+  setOnError: (options: { callbackId: string }) => void;
+  clearOnError: () => void;
+
+  getCurrentDuration: () => number;
+  getFilePath: () => string | null;
 }
 
 export interface IAudioDecoder {

package/src/plugin/withAudioAPI.ts

@@ -4,6 +4,8 @@ import {
   ConfigPlugin,
   withInfoPlist,
   withAndroidManifest,
+  withGradleProperties,
+  withPodfile,
 } from '@expo/config-plugins';
 const pkg = require('react-native-audio-api/package.json');
 
@@ -13,6 +15,7 @@ interface Options {
   androidPermissions: string[];
   androidForegroundService: boolean;
   androidFSTypes: string[];
+  disableFFmpeg: boolean;
 }
 
 const withDefaultOptions = (options: Partial<Options>): Options => {
@@ -24,6 +27,7 @@ const withDefaultOptions = (options: Partial<Options>): Options => {
     ],
     androidForegroundService: true,
     androidFSTypes: ['mediaPlayback'],
+    disableFFmpeg: false,
     ...options,
   };
 };
@@ -88,6 +92,59 @@ const withForegroundService: ConfigPlugin<Options> = (
   });
 };
 
+const withFFmpegConfig: ConfigPlugin<Options> = (config, options) => {
+  const iosConf = withPodfile(config, (mod) => {
+    let contents = mod.modResults.contents;
+    const ffmpegRegex = /^.*ENV\['DISABLE_AUDIOAPI_FFMPEG'\].*$/gm;
+    const podfileString = options.disableFFmpeg
+      ? `ENV['DISABLE_AUDIOAPI_FFMPEG'] = '1'`
+      : '';
+    // No existing setting
+    if (contents.search(ffmpegRegex) === -1) {
+      if (options.disableFFmpeg) {
+        if (contents.endsWith('\n')) {
+          contents = `${contents}${podfileString}`;
+        } else {
+          contents = `${contents}\n${podfileString}`;
+        }
+        mod.modResults.contents = contents;
+      }
+    } else {
+      // Existing setting found, will replace
+      contents = contents.replace(ffmpegRegex, podfileString);
+    }
+
+    mod.modResults.contents = contents;
+    return mod;
+  });
+
+  const finalConf = withGradleProperties(iosConf, (mod) => {
+    const gradleProperties = mod.modResults;
+
+    const existingIndex = gradleProperties.findIndex(
+      (prop) => prop.type === 'property' && prop.key === 'disableAudioapiFFmpeg'
+    );
+    if (existingIndex !== -1) {
+      gradleProperties.splice(existingIndex, 1);
+    } else if (!options.disableFFmpeg) {
+      // No existing setting and FFmpeg is enabled, do nothing.
+      return mod;
+    }
+
+    if (options.disableFFmpeg) {
+      gradleProperties.push({
+        type: 'property',
+        key: 'disableAudioapiFFmpeg',
+        value: options.disableFFmpeg ? 'true' : 'false',
+      });
+    }
+
+    return mod;
+  });
+
+  return finalConf;
+};
+
 const withAudioAPI: ConfigPlugin<Options> = (config, optionsIn) => {
   const options = withDefaultOptions(optionsIn ?? {});
 
@@ -105,6 +162,10 @@ const withAudioAPI: ConfigPlugin<Options> = (config, optionsIn) => {
     config = withIosMicrophonePermission(config, options);
   }
 
+  if (options.disableFFmpeg !== undefined) {
+    config = withFFmpegConfig(config, options);
+  }
+
   return config;
 };
 

package/src/specs/NativeAudioAPIModule.ts

@@ -1,7 +1,11 @@
 'use strict';
-import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native';
-import { PermissionStatus, AudioDevicesInfo } from '../system/types';
+import { TurboModuleRegistry } from 'react-native';
+import { AudioDevicesInfo, PermissionStatus } from '../system/types';
+
+type OptionsMap = { [key: string]: string | boolean | number | undefined };
+type NotificationOpResponse = { success: boolean; error?: string };
+type NotificationType = 'playback' | 'recording' | 'simple';
 
 interface Spec extends TurboModule {
   install(): boolean;
@@ -15,15 +19,9 @@ interface Spec extends TurboModule {
     options: Array<string>,
     allowHaptics: boolean
   ): void;
-
-  // Lock Screen Info
-  setLockScreenInfo(info: {
-    [key: string]: string | boolean | number | undefined;
-  }): void;
-  resetLockScreenInfo(): void;
+  disableSessionManagement(): void;
 
   // Remote commands, system events and interruptions
-  enableRemoteCommand(name: string, enabled: boolean): void;
   observeAudioInterruptions(enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
   observeVolumeChanges(enabled: boolean): void;
@@ -31,9 +29,28 @@ interface Spec extends TurboModule {
   // Permissions
   requestRecordingPermissions(): Promise<PermissionStatus>;
   checkRecordingPermissions(): Promise<PermissionStatus>;
+  requestNotificationPermissions(): Promise<PermissionStatus>;
+  checkNotificationPermissions(): Promise<PermissionStatus>;
 
   // Audio devices
   getDevicesInfo(): Promise<AudioDevicesInfo>;
+
+  // New notification system
+  registerNotification(
+    type: NotificationType,
+    key: string
+  ): Promise<NotificationOpResponse>;
+  showNotification(
+    key: string,
+    options: OptionsMap
+  ): Promise<NotificationOpResponse>;
+  updateNotification(
+    key: string,
+    options: OptionsMap
+  ): Promise<NotificationOpResponse>;
+  hideNotification(key: string): Promise<NotificationOpResponse>;
+  unregisterNotification(key: string): Promise<NotificationOpResponse>;
+  isNotificationActive(key: string): Promise<boolean>;
 }
 
 const NativeAudioAPIModule = TurboModuleRegistry.get<Spec>('AudioAPIModule');

package/src/system/AudioManager.ts

@@ -1,26 +1,7 @@
-import {
-  SessionOptions,
-  LockScreenInfo,
-  PermissionStatus,
-  AudioDevicesInfo,
-} from './types';
-import {
-  SystemEventName,
-  SystemEventCallback,
-  RemoteCommandEventName,
-} from '../events/types';
-import { NativeAudioAPIModule } from '../specs';
+import { SessionOptions, PermissionStatus, AudioDevicesInfo } from './types';
+import { SystemEventName, SystemEventCallback } from '../events/types';
 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 { NativeAudioAPIModule } from '../specs';
 
 class AudioManager {
   private readonly audioEventEmitter: AudioEventEmitter;
@@ -45,12 +26,8 @@ class AudioManager {
     );
   }
 
-  setLockScreenInfo(info: LockScreenInfo) {
-    NativeAudioAPIModule!.setLockScreenInfo(info);
-  }
-
-  resetLockScreenInfo() {
-    NativeAudioAPIModule!.resetLockScreenInfo();
+  disableSessionManagement() {
+    NativeAudioAPIModule!.disableSessionManagement();
   }
 
   observeAudioInterruptions(enabled: boolean) {
@@ -78,10 +55,6 @@ class AudioManager {
     NativeAudioAPIModule!.observeVolumeChanges(enabled);
   }
 
-  enableRemoteCommand(name: RemoteCommandEventName, enabled: boolean) {
-    NativeAudioAPIModule!.enableRemoteCommand(name, enabled);
-  }
-
   addSystemEventListener<Name extends SystemEventName>(
     name: Name,
     callback: SystemEventCallback<Name>
@@ -97,6 +70,14 @@ class AudioManager {
     return NativeAudioAPIModule!.checkRecordingPermissions();
   }
 
+  async requestNotificationPermissions(): Promise<PermissionStatus> {
+    return NativeAudioAPIModule!.requestNotificationPermissions();
+  }
+
+  async checkNotificationPermissions(): Promise<PermissionStatus> {
+    return NativeAudioAPIModule!.checkNotificationPermissions();
+  }
+
   async getDevicesInfo(): Promise<AudioDevicesInfo> {
     return NativeAudioAPIModule!.getDevicesInfo();
   }

package/src/system/index.ts

@@ -1 +1,2 @@
 export { default } from './AudioManager';
+export * from './notification';

package/src/system/notification/PlaybackNotificationManager.ts

@@ -0,0 +1,197 @@
+import { AudioEventEmitter, AudioEventSubscription } from '../../events';
+import { NativeAudioAPIModule } from '../../specs';
+import type {
+  NotificationEvents,
+  NotificationManager,
+  PlaybackControlName,
+  PlaybackNotificationEventName,
+  PlaybackNotificationInfo,
+} from './types';
+
+/// Manager for media playback notifications with controls and MediaSession integration.
+class PlaybackNotificationManager
+  implements
+    NotificationManager<
+      PlaybackNotificationInfo,
+      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.
+  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');
+    }
+
+    const result = await NativeAudioAPIModule.showNotification(
+      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);
+    }
+  }
+
+  /// 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;
+  }
+
+  /// Enable or disable a specific playback control.
+  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');
+    }
+
+    const params = { control, enabled };
+    const result = await NativeAudioAPIModule.updateNotification(
+      this.notificationKey,
+      params as Record<string, string | number | boolean | undefined>
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+  }
+
+  /// 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 for notification actions.
+  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();