react-native-audio-api 0.12.0-nightly-75589dc-20260121 → 0.12.0-nightly-6a44b58-20260123

package/src/development/react/Audio/Audio.web.tsx

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { AudioProps } from './types';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const Audio: React.FC<AudioProps> = (props) => {
+  return null;
+};
+
+export default Audio;

package/src/development/react/Audio/index.ts

@@ -0,0 +1,3 @@
+export { default } from './Audio';
+
+export type { AudioProps, AudioSource, TimeRanges } from './types';

package/src/development/react/Audio/types.ts

@@ -0,0 +1,64 @@
+export interface AudioURISource {
+  uri?: string | undefined;
+  // bundle?: string | undefined;
+  method?: string | undefined;
+  headers?: { [key: string]: string } | undefined;
+  // cache?: 'default' | 'reload' | 'force-cache' | 'only-if-cached' | undefined;
+  body?: string | undefined;
+}
+
+export type AudioRequireSource = number;
+
+export interface TimeRanges {
+  length: number;
+  start(index: number): number;
+  end(index: number): number;
+}
+
+export type AudioSource =
+  | AudioURISource
+  | AudioRequireSource
+  | ReadonlyArray<AudioURISource>;
+
+export type PreloadType = 'auto' | 'metadata' | 'none';
+
+interface AudioControlProps {
+  autoPlay: boolean;
+  controls: boolean; // TBD: should we support control display at all?
+  loop: boolean;
+  muted: boolean;
+  preload: PreloadType;
+  source: AudioSource;
+  playbackRate: number;
+  preservesPitch: boolean;
+  volume: number;
+}
+
+interface AudioReadonlyProps {
+  // TODO: decide if we want to expose them this way
+  // duration: number;
+  // currentTime: number;
+  // ended: boolean;
+  // paused: boolean;
+  // buffered: TimeRanges;
+}
+
+type TMPEmptyEventHandler = () => void;
+
+interface AudioEventProps {
+  onLoadStart?: TMPEmptyEventHandler;
+  onLoad?: TMPEmptyEventHandler;
+  onError?: TMPEmptyEventHandler;
+  onProgress?: TMPEmptyEventHandler;
+  onSeeked?: TMPEmptyEventHandler;
+  onEnded?: TMPEmptyEventHandler;
+  onPlay?: TMPEmptyEventHandler;
+  onPause?: TMPEmptyEventHandler;
+}
+
+export interface AudioPropsBase
+  extends AudioControlProps,
+    AudioReadonlyProps,
+    AudioEventProps {}
+
+export type AudioProps = Partial<AudioPropsBase> & { source: AudioSource };

package/src/development/react/Audio/utils.ts

@@ -0,0 +1,86 @@
+import { useMemo } from 'react';
+import { AudioProps, AudioPropsBase } from './types';
+
+export function withPropsDefaults(props: AudioProps): AudioPropsBase {
+  return {
+    ...props,
+    autoPlay: props.autoPlay ?? false,
+    controls: props.controls ?? false,
+    loop: props.loop ?? false,
+    muted: props.muted ?? false,
+    preload: props.preload ?? 'auto',
+    source: props.source ?? [],
+    playbackRate: props.playbackRate ?? 1.0,
+    preservesPitch: props.preservesPitch ?? true,
+    volume: props.volume ?? 1.0,
+  };
+}
+
+export function useStableAudioProps(props: AudioProps): AudioPropsBase {
+  const {
+    // Control Props
+    autoPlay,
+    controls,
+    loop,
+    muted,
+    preload,
+    source,
+    playbackRate,
+    preservesPitch,
+    volume,
+
+    // Event Props
+    onLoadStart,
+    onLoad,
+    onError,
+    onProgress,
+    onSeeked,
+    onEnded,
+    onPlay,
+    onPause,
+  } = withPropsDefaults(props);
+
+  return useMemo(
+    () => ({
+      // Control Props
+      autoPlay,
+      controls,
+      loop,
+      muted,
+      preload,
+      source,
+      playbackRate,
+      preservesPitch,
+      volume,
+
+      // Event Props
+      onLoadStart,
+      onLoad,
+      onError,
+      onProgress,
+      onSeeked,
+      onEnded,
+      onPlay,
+      onPause,
+    }),
+    [
+      autoPlay,
+      controls,
+      loop,
+      muted,
+      preload,
+      source,
+      playbackRate,
+      preservesPitch,
+      volume,
+      onLoadStart,
+      onLoad,
+      onError,
+      onProgress,
+      onSeeked,
+      onEnded,
+      onPlay,
+      onPause,
+    ]
+  );
+}

package/src/development/react/index.ts

@@ -0,0 +1,2 @@
+export * from './Audio';
+export { default as Audio } from './Audio';

package/src/events/types.ts

@@ -46,12 +46,13 @@ interface RemoteCommandEvents {
 type SystemEvents = RemoteCommandEvents & {
   volumeChange: EventTypeWithValue;
   interruption: OnInterruptionEventType;
+  duck: EventEmptyType;
   routeChange: OnRouteChangeEventType;
 };
 
-export interface OnEndedEventType extends EventEmptyType {
-  bufferId: string | undefined;
-  isLast: boolean | undefined;
+export interface OnBufferEndEventType {
+  bufferId: string;
+  isLastBufferInQueue: boolean;
 }
 
 /**
@@ -79,10 +80,11 @@ export interface OnAudioReadyEventType {
 }
 
 interface AudioAPIEvents {
-  ended: OnEndedEventType;
+  ended: EventEmptyType;
   loopEnded: EventEmptyType;
   audioReady: OnAudioReadyEventType;
   positionChanged: EventTypeWithValue;
+  bufferEnded: OnBufferEndEventType;
   audioError: EventEmptyType; // to change
   systemStateChanged: EventEmptyType; // to change
   recorderError: OnRecorderErrorEventType;

package/src/interfaces.ts

@@ -229,6 +229,9 @@ export interface IAudioBufferQueueSourceNode
   enqueueBuffer: (audioBuffer: IAudioBuffer) => string;
   start: (when?: number, offset?: number) => void;
   pause: () => void;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onBufferEnded: string;
 }
 
 export interface IConvolverNode extends IAudioNode {

package/src/specs/NativeAudioAPIModule.ts

@@ -6,6 +6,11 @@ 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';
+type AudioFocusType =
+  | 'gain'
+  | 'gainTransient'
+  | 'gainTransientExclusive'
+  | 'gainTransientMayDuck';
 
 interface Spec extends TurboModule {
   install(): boolean;
@@ -22,7 +27,7 @@ interface Spec extends TurboModule {
   disableSessionManagement(): void;
 
   // Remote commands, system events and interruptions
-  observeAudioInterruptions(enabled: boolean): void;
+  observeAudioInterruptions(focusType: AudioFocusType, enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
   observeVolumeChanges(enabled: boolean): void;
 

package/src/specs/NativeAudioAPIModule.web.ts

@@ -1,5 +1,9 @@
 import { TurboModule } from 'react-native';
-import { AudioDevicesInfo, PermissionStatus } from '../system/types';
+import {
+  AudioDevicesInfo,
+  AudioFocusType,
+  PermissionStatus,
+} from '../system/types';
 
 // copy of spec from NativeAudioAPIModule.ts
 type OptionsMap = {
@@ -23,7 +27,7 @@ interface Spec extends TurboModule {
   disableSessionManagement(): void;
 
   // Remote commands, system events and interruptions
-  observeAudioInterruptions(enabled: boolean): void;
+  observeAudioInterruptions(focusType: AudioFocusType, enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
   observeVolumeChanges(enabled: boolean): void;
 

package/src/system/AudioManager.ts

@@ -7,6 +7,7 @@ import {
   IAudioManager,
   PermissionStatus,
   SessionOptions,
+  AudioFocusType,
 } from './types';
 
 class AudioManager implements IAudioManager {
@@ -43,8 +44,13 @@ class AudioManager implements IAudioManager {
     NativeAudioAPIModule.disableSessionManagement();
   }
 
-  observeAudioInterruptions(enabled: boolean) {
-    NativeAudioAPIModule.observeAudioInterruptions(enabled);
+  observeAudioInterruptions(param: AudioFocusType | boolean | null) {
+    if (typeof param === 'string') {
+      NativeAudioAPIModule.observeAudioInterruptions(param, true);
+    } else {
+      // audiofocusgain as default value if not provided
+      NativeAudioAPIModule.observeAudioInterruptions('gain', param === true);
+    }
   }
 
   /**

package/src/system/types.ts

@@ -30,6 +30,12 @@ export type IOSOption =
   | 'overrideMutedMicrophoneInterruption'
   | 'interruptSpokenAudioAndMixWithOthers';
 
+export type AudioFocusType =
+  | 'gain'
+  | 'gainTransient'
+  | 'gainTransientExclusive'
+  | 'gainTransientMayDuck';
+
 export interface SessionOptions {
   iosMode?: IOSMode;
   iosOptions?: IOSOption[];
@@ -60,7 +66,7 @@ export interface IAudioManager {
   disableSessionManagement(): void;
   observeAudioInterruptions(enabled: boolean): void;
   activelyReclaimSession(enabled: boolean): void;
-  observeVolumeChanges(enabled: boolean): void;
+  observeAudioInterruptions(param: AudioFocusType | boolean | null): void;
   addSystemEventListener<Name extends SystemEventName>(
     name: Name,
     callback: SystemEventCallback<Name>

package/src/web-core/AudioScheduledSourceNode.tsx

@@ -4,6 +4,7 @@ import { RangeError, InvalidStateError } from '../errors';
 
 export default class AudioScheduledSourceNode extends AudioNode {
   protected hasBeenStarted: boolean = false;
+  private onEndedCallback?: (event: EventEmptyType) => void;
 
   public start(when: number = 0): void {
     if (when < 0) {
@@ -36,8 +37,12 @@ export default class AudioScheduledSourceNode extends AudioNode {
     (this.node as globalThis.AudioScheduledSourceNode).stop(when);
   }
 
-  // eslint-disable-next-line accessor-pairs
+  public get onEnded(): ((event: EventEmptyType) => void) | undefined {
+    return this.onEndedCallback;
+  }
+
   public set onEnded(callback: (event: EventEmptyType) => void | null) {
     (this.node as globalThis.AudioScheduledSourceNode).onended = callback;
+    this.onEndedCallback = callback;
   }
 }