react-native-audio-api 0.11.0-alpha.4 → 0.11.0-alpha.6

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();

package/src/system/notification/SimpleNotificationManager.ts

@@ -0,0 +1,170 @@
+import { NativeAudioAPIModule } from '../../specs';
+import { AudioEventEmitter, AudioEventSubscription } from '../../events';
+import type { NotificationManager, SimpleNotificationOptions } from './types';
+
+/// Simple notification manager for basic notifications with title and text.
+/// Implements the generic NotificationManager interface.
+// It is only a showcase
+class SimpleNotificationManager
+  implements
+    NotificationManager<
+      SimpleNotificationOptions,
+      SimpleNotificationOptions,
+      never
+    >
+{
+  private notificationKey = 'simple';
+  private isRegistered = false;
+  private isShown = false;
+  private audioEventEmitter: AudioEventEmitter;
+
+  constructor() {
+    this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
+  }
+
+  /// Register the simple notification (must be called before showing).
+  async register(): Promise<void> {
+    if (this.isRegistered) {
+      console.warn('SimpleNotification is already registered');
+      return;
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.registerNotification(
+      'simple',
+      this.notificationKey
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isRegistered = true;
+  }
+
+  /// Show the notification with initial options.
+  async show(options: SimpleNotificationOptions): Promise<void> {
+    if (!this.isRegistered) {
+      throw new Error(
+        'SimpleNotification must be registered before showing. Call register() first.'
+      );
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.showNotification(
+      this.notificationKey,
+      options as Record<string, string | number | boolean | undefined>
+    );
+
+    if (result.error) {
+      throw new Error(result.error);
+    }
+
+    this.isShown = true;
+  }
+
+  /// Update the notification with new options.
+  async update(options: SimpleNotificationOptions): Promise<void> {
+    if (!this.isShown) {
+      console.warn('SimpleNotification is not shown. Call show() first.');
+      return;
+    }
+
+    if (!NativeAudioAPIModule) {
+      throw new Error('NativeAudioAPIModule is not available');
+    }
+
+    const result = await NativeAudioAPIModule.updateNotification(
+      this.notificationKey,
+      options 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;
+  }
+
+  /// 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 (SimpleNotification doesn't emit events).
+  addEventListener<T extends never>(
+    _eventName: T,
+    _callback: (event: never) => void
+  ): AudioEventSubscription {
+    // SimpleNotification doesn't emit events, return a no-op subscription
+    console.warn('SimpleNotification does not support event listeners');
+    return this.audioEventEmitter.addAudioEventListener(
+      // Using a valid event name for the no-op subscription
+      'playbackNotificationPlay',
+      () => {}
+    );
+  }
+
+  /// Remove an event listener.
+  removeEventListener(subscription: AudioEventSubscription): void {
+    subscription.remove();
+  }
+}
+
+export default new SimpleNotificationManager();

package/src/system/notification/index.ts

@@ -0,0 +1,4 @@
+export { default as PlaybackNotificationManager } from './PlaybackNotificationManager';
+export { default as RecordingNotificationManager } from './RecordingNotificationManager';
+export { default as SimpleNotificationManager } from './SimpleNotificationManager';
+export * from './types';

package/src/system/notification/types.ts

@@ -0,0 +1,111 @@
+import type { AudioEventSubscription } from '../../events';
+import { EventEmptyType, EventTypeWithValue } from '../../events/types';
+
+/// Generic notification manager interface that all notification managers should implement.
+/// Provides a consistent API for managing notification lifecycle and events.
+export interface NotificationManager<
+  TShowOptions,
+  TUpdateOptions,
+  TEventName extends NotificationEventName,
+> {
+  /// Register the notification (must be called before showing).
+  register(): Promise<void>;
+
+  /// Show the notification with initial options.
+  show(options: TShowOptions): Promise<void>;
+
+  /// Update the notification with new options.
+  update(options: TUpdateOptions): Promise<void>;
+
+  /// Hide the notification (can be shown again later).
+  hide(): Promise<void>;
+
+  /// Unregister the notification (must register again to use).
+  unregister(): Promise<void>;
+
+  /// Check if the notification is currently active.
+  isActive(): Promise<boolean>;
+
+  /// Add an event listener for notification events.
+  addEventListener<T extends TEventName>(
+    eventName: T,
+    callback: NotificationCallback<T>
+  ): AudioEventSubscription;
+
+  /// Remove an event listener.
+  removeEventListener(subscription: AudioEventSubscription): void;
+}
+
+/// Metadata and state information for playback notifications.
+export interface PlaybackNotificationInfo {
+  title?: string;
+  artist?: string;
+  album?: string;
+  artwork?: string | { uri: string };
+  androidSmallIcon?: string | { uri: string };
+  duration?: number;
+  elapsedTime?: number;
+  speed?: number;
+  state?: 'playing' | 'paused';
+}
+
+/// Available playback control actions.
+export type PlaybackControlName =
+  | 'play'
+  | 'pause'
+  | 'next'
+  | 'previous'
+  | 'skipForward'
+  | 'skipBackward'
+  | 'seekTo';
+
+/// Event names for playback notification actions.
+interface PlaybackNotificationEvent {
+  playbackNotificationPlay: EventEmptyType;
+  playbackNotificationPause: EventEmptyType;
+  playbackNotificationNext: EventEmptyType;
+  playbackNotificationPrevious: EventEmptyType;
+  playbackNotificationSkipForward: EventTypeWithValue;
+  playbackNotificationSkipBackward: EventTypeWithValue;
+  playbackNotificationSeekTo: EventTypeWithValue;
+  playbackNotificationDismissed: EventEmptyType;
+}
+
+export type PlaybackNotificationEventName = keyof PlaybackNotificationEvent;
+
+/// Metadata and state information for recording notifications.
+export interface RecordingNotificationInfo {
+  title?: string;
+  description?: string;
+  artwork?: string | { uri: string };
+  state?: 'recording' | 'stopped';
+  control?: RecordingControlName;
+  enabled?: boolean;
+}
+
+/// Available recording control actions.
+export type RecordingControlName = 'start' | 'stop';
+
+/// Event names for recording notification actions.
+interface RecordingNotificationEvent {
+  recordingNotificationStart: EventEmptyType;
+  recordingNotificationStop: EventEmptyType;
+  recordingNotificationDismissed: EventEmptyType;
+}
+
+export type RecordingNotificationEventName = keyof RecordingNotificationEvent;
+
+export type NotificationEvents = PlaybackNotificationEvent &
+  RecordingNotificationEvent;
+
+export type NotificationEventName = keyof NotificationEvents;
+
+export type NotificationCallback<Name extends NotificationEventName> = (
+  event: NotificationEvents[Name]
+) => void;
+
+/// Options for a simple notification with title and text.
+export interface SimpleNotificationOptions {
+  title?: string;
+  text?: string;
+}

package/src/system/types.ts

@@ -34,24 +34,6 @@ export interface SessionOptions {
   iosAllowHaptics?: boolean;
 }
 
-export type MediaState = 'state_playing' | 'state_paused';
-
-interface BaseLockScreenInfo {
-  [key: string]: string | boolean | number | undefined;
-}
-
-export interface LockScreenInfo extends BaseLockScreenInfo {
-  title?: string;
-  artwork?: string;
-  artist?: string;
-  album?: string;
-  duration?: number;
-  description?: string; // android only
-  state?: MediaState;
-  speed?: number;
-  elapsedTime?: number;
-}
-
 export type PermissionStatus = 'Undetermined' | 'Denied' | 'Granted';
 
 export interface AudioDeviceInfo {

package/src/types.ts

@@ -44,23 +44,29 @@ export interface OfflineAudioContextOptions {
 }
 
 export enum FileDirectory {
-  Document = 1,
-  Cache = 2,
+  Document = 0,
+  Cache = 1,
 }
 
 export enum FileFormat {
-  Wav = 1,
-  Caf = 2,
-  M4A = 3,
-  Flac = 4,
+  Wav = 0,
+  Caf = 1,
+  M4A = 2,
+  Flac = 3,
 }
 
 export enum IOSAudioQuality {
-  Min = 1,
-  Low = 2,
-  Medium = 3,
-  High = 4,
-  Max = 5,
+  Min = 0,
+  Low = 1,
+  Medium = 2,
+  High = 3,
+  Max = 4,
+}
+
+export enum BitDepth {
+  Bit16 = 0,
+  Bit24 = 1,
+  Bit32 = 2,
 }
 
 export enum FlacCompressionLevel {
@@ -75,12 +81,6 @@ export enum FlacCompressionLevel {
   L8 = 8,
 }
 
-export enum BitDepth {
-  Bit16 = 1,
-  Bit24 = 2,
-  Bit32 = 3,
-}
-
 export interface FilePresetType {
   bitRate: number;
   sampleRate: number;

package/src/web-system/index.ts

@@ -0,0 +1 @@
+export * from './notification';

package/src/web-system/notification/PlaybackNotificationManager.ts

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-useless-constructor */
+/* eslint-disable @typescript-eslint/require-await */
+
+import type { AudioEventSubscription } from '../../events';
+import type {
+  NotificationManager,
+  PlaybackNotificationInfo,
+  PlaybackControlName,
+  PlaybackNotificationEventName,
+  NotificationEvents,
+} from '../../system';
+
+/// Mock Manager for playback notifications. Does nothing.
+class PlaybackNotificationManager
+  implements
+    NotificationManager<
+      PlaybackNotificationInfo,
+      PlaybackNotificationInfo,
+      PlaybackNotificationEventName
+    >
+{
+  private isRegistered = false;
+  private isShown = false;
+
+  constructor() {}
+
+  async register(): Promise<void> {}
+
+  async show(info: PlaybackNotificationInfo): Promise<void> {}
+
+  async update(info: PlaybackNotificationInfo): Promise<void> {}
+
+  async hide(): Promise<void> {}
+
+  async unregister(): Promise<void> {}
+
+  async enableControl(
+    control: PlaybackControlName,
+    enabled: boolean
+  ): Promise<void> {}
+
+  async isActive(): Promise<boolean> {
+    return this.isShown;
+  }
+
+  addEventListener<T extends PlaybackNotificationEventName>(
+    eventName: T,
+    callback: (event: NotificationEvents[T]) => void
+  ): AudioEventSubscription {
+    // dummy subscription object with a no-op remove method
+    return {
+      remove: () => {},
+    } as unknown as AudioEventSubscription;
+  }
+
+  removeEventListener(subscription: AudioEventSubscription): void {}
+}
+
+export default new PlaybackNotificationManager();