react-native-audio-api 0.11.0-nightly-db51488-20251208 → 0.11.0-nightly-6ba0571-20251209

package/src/api.ts

@@ -28,6 +28,12 @@ export { default as WorkletSourceNode } from './core/WorkletSourceNode';
 export { default as useSystemVolume } from './hooks/useSystemVolume';
 export { default as AudioManager } from './system';
 
+// Notification System
+export {
+  PlaybackNotificationManager,
+  RecordingNotificationManager,
+} from './system/notification';
+
 export {
   AudioWorkletRuntime,
   BiquadFilterType,
@@ -43,12 +49,21 @@ export {
   IOSCategory,
   IOSMode,
   IOSOption,
-  LockScreenInfo,
-  MediaState,
   PermissionStatus,
   SessionOptions,
 } from './system/types';
 
+export {
+  NotificationManager,
+  PlaybackNotificationInfo,
+  PlaybackControlName,
+  PlaybackNotificationEventName,
+  RecordingNotificationInfo,
+  RecordingControlName,
+  RecordingNotificationEventName,
+  SimpleNotificationOptions,
+} from './system/notification';
+
 export {
   IndexSizeError,
   InvalidAccessError,

package/src/api.web.ts

@@ -32,11 +32,16 @@ export {
   IOSMode,
   IOSOption,
   SessionOptions,
-  MediaState,
-  LockScreenInfo,
   PermissionStatus,
 } from './system/types';
 
+export {
+  PlaybackNotificationManager,
+  RecordingNotificationManager,
+} from './web-system';
+
+export * from './system/notification/types';
+
 export {
   IndexSizeError,
   InvalidAccessError,

package/src/events/types.ts

@@ -1,4 +1,5 @@
 import AudioBuffer from '../core/AudioBuffer';
+import { NotificationEvents } from '../system';
 
 export interface EventEmptyType {}
 
@@ -8,7 +9,7 @@ export interface EventTypeWithValue {
 
 interface OnInterruptionEventType {
   type: 'ended' | 'began';
-  shouldResume: boolean;
+  isTransient: boolean;
 }
 
 interface OnRouteChangeEventType {
@@ -23,22 +24,7 @@ interface OnRouteChangeEventType {
     | 'NoSuitableRouteForCategory';
 }
 
-interface RemoteCommandEvents {
-  remotePlay: EventEmptyType;
-  remotePause: EventEmptyType;
-  remoteStop: EventEmptyType;
-  remoteTogglePlayPause: EventEmptyType;
-  remoteChangePlaybackRate: EventTypeWithValue;
-  remoteNextTrack: EventEmptyType;
-  remotePreviousTrack: EventEmptyType;
-  remoteSkipForward: EventTypeWithValue;
-  remoteSkipBackward: EventTypeWithValue;
-  remoteSeekForward: EventEmptyType;
-  remoteSeekBackward: EventEmptyType;
-  remoteChangePlaybackPosition: EventTypeWithValue;
-}
-
-type SystemEvents = RemoteCommandEvents & {
+type SystemEvents = {
   volumeChange: EventTypeWithValue;
   interruption: OnInterruptionEventType;
   routeChange: OnRouteChangeEventType;
@@ -64,9 +50,7 @@ interface AudioAPIEvents {
   systemStateChanged: EventEmptyType; // to change
 }
 
-type AudioEvents = SystemEvents & AudioAPIEvents;
-
-export type RemoteCommandEventName = keyof RemoteCommandEvents;
+type AudioEvents = SystemEvents & AudioAPIEvents & NotificationEvents;
 
 export type SystemEventName = keyof SystemEvents;
 export type SystemEventCallback<Name extends SystemEventName> = (

package/src/specs/NativeAudioAPIModule.ts

@@ -3,6 +3,10 @@ import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native';
 import { PermissionStatus, AudioDevicesInfo } 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;
   getDevicePreferredSampleRate(): number;
@@ -17,14 +21,7 @@ interface Spec extends TurboModule {
   ): void;
   disableSessionManagement(): void;
 
-  // Lock Screen Info
-  setLockScreenInfo(info: {
-    [key: string]: string | boolean | number | undefined;
-  }): void;
-  resetLockScreenInfo(): 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;
@@ -32,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,16 +1,7 @@
+import { SessionOptions, PermissionStatus, AudioDevicesInfo } from './types';
+import { SystemEventName, SystemEventCallback } from '../events/types';
 import { AudioEventEmitter, AudioEventSubscription } from '../events';
-import {
-  RemoteCommandEventName,
-  SystemEventCallback,
-  SystemEventName,
-} from '../events/types';
 import { NativeAudioAPIModule } from '../specs';
-import {
-  AudioDevicesInfo,
-  LockScreenInfo,
-  PermissionStatus,
-  SessionOptions,
-} from './types';
 
 class AudioManager {
   private readonly audioEventEmitter: AudioEventEmitter;
@@ -39,14 +30,6 @@ class AudioManager {
     NativeAudioAPIModule!.disableSessionManagement();
   }
 
-  setLockScreenInfo(info: LockScreenInfo) {
-    NativeAudioAPIModule!.setLockScreenInfo(info);
-  }
-
-  resetLockScreenInfo() {
-    NativeAudioAPIModule!.resetLockScreenInfo();
-  }
-
   observeAudioInterruptions(enabled: boolean) {
     NativeAudioAPIModule!.observeAudioInterruptions(enabled);
   }
@@ -72,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>
@@ -91,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,193 @@
+import { NativeAudioAPIModule } from '../../specs';
+import { AudioEventEmitter, AudioEventSubscription } from '../../events';
+import type {
+  NotificationManager,
+  PlaybackNotificationInfo,
+  PlaybackControlName,
+  PlaybackNotificationEventName,
+  NotificationEvents,
+} 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
+    );
+  }
+
+  /// 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();

package/src/system/notification/RecordingNotificationManager.ts

@@ -0,0 +1,242 @@
+import { Platform } from 'react-native';
+import { NativeAudioAPIModule } from '../../specs';
+import { AudioEventEmitter, AudioEventSubscription } from '../../events';
+import type {
+  NotificationManager,
+  RecordingNotificationInfo,
+  RecordingControlName,
+  RecordingNotificationEventName,
+  NotificationEvents,
+} from './types';
+
+/// Manager for recording notifications with controls.
+class RecordingNotificationManager
+  implements
+    NotificationManager<
+      RecordingNotificationInfo,
+      RecordingNotificationInfo,
+      RecordingNotificationEventName
+    >
+{
+  private notificationKey = 'recording';
+  private isRegistered = false;
+  private isShown = false;
+  private audioEventEmitter: AudioEventEmitter;
+  private isIOS = Platform.OS === 'ios';
+
+  constructor() {
+    this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
+  }
+
+  /// Register the recording notification (must be called before showing).
+  async register(): Promise<void> {
+    if (this.isRegistered) {
+      console.warn('RecordingNotification is already registered');
+      return;
+    }
+
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      this.isRegistered = true;
+      return;
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.registerNotification(
+      'recording',
+      this.notificationKey
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isRegistered = true;
+  }
+
+  /// Show the notification with initial metadata.
+  async show(info: RecordingNotificationInfo): Promise<void> {
+    if (!this.isRegistered) {
+      throw new Error(
+        'RecordingNotification must be registered before showing. Call register() first.'
+      );
+    }
+
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      this.isShown = true;
+      return;
+    }
+
+    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: RecordingNotificationInfo): Promise<void> {
+    if (!this.isShown) {
+      console.warn('RecordingNotification is not shown. Call show() first.');
+      return;
+    }
+
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      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;
+    }
+
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      this.isShown = false;
+      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();
+    }
+
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      this.isRegistered = false;
+      return;
+    }
+
+    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 recording control.
+  async enableControl(
+    control: RecordingControlName,
+    enabled: boolean
+  ): Promise<void> {
+    if (!this.isRegistered) {
+      console.warn('RecordingNotification is not registered');
+      return;
+    }
+
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      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> {
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      return this.isShown;
+    }
+
+    if (!NativeAudioAPIModule) {
+      return false;
+    }
+
+    return await NativeAudioAPIModule.isNotificationActive(
+      this.notificationKey
+    );
+  }
+
+  /// Add an event listener for notification actions.
+  addEventListener<T extends RecordingNotificationEventName>(
+    eventName: T,
+    callback: (event: NotificationEvents[T]) => void
+  ): AudioEventSubscription {
+    // Recording notifications are only supported on Android
+    if (this.isIOS) {
+      // Return a dummy subscription for iOS
+      return {
+        remove: () => {},
+      } as unknown as AudioEventSubscription;
+    }
+
+    return this.audioEventEmitter.addAudioEventListener(eventName, callback);
+  }
+
+  /** Remove an event listener. */
+  removeEventListener(subscription: AudioEventSubscription): void {
+    subscription.remove();
+  }
+}
+
+export default new RecordingNotificationManager();