react-native-audio-api 0.6.0-rc.4 → 0.6.0

package/src/events/AudioEventEmitter.ts

@@ -0,0 +1,29 @@
+import { AudioEventName, AudioEventCallback } from './types';
+import AudioEventSubscription from './AudioEventSubscription';
+import { IAudioEventEmitter } from '../interfaces';
+
+export default class AudioEventEmitter {
+  private readonly audioEventEmitter: IAudioEventEmitter;
+
+  constructor(audioEventEmitter: IAudioEventEmitter) {
+    this.audioEventEmitter = audioEventEmitter;
+  }
+
+  addAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    callback: AudioEventCallback<Name>
+  ): AudioEventSubscription {
+    const subscriptionId = this.audioEventEmitter.addAudioEventListener(
+      name,
+      callback
+    );
+    return new AudioEventSubscription(subscriptionId, name, this);
+  }
+
+  removeAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    subscriptionId: string
+  ): void {
+    this.audioEventEmitter.removeAudioEventListener(name, subscriptionId);
+  }
+}

package/src/events/AudioEventSubscription.ts

@@ -0,0 +1,26 @@
+import { AudioEventName } from './types';
+import { AudioEventEmitter } from './';
+
+export default class AudioEventSubscription {
+  private readonly audioEventEmitter: AudioEventEmitter;
+  private readonly eventName: AudioEventName;
+  /** @internal */
+  public readonly subscriptionId: string;
+
+  constructor(
+    subscriptionId: string,
+    eventName: AudioEventName,
+    audioEventEmitter: AudioEventEmitter
+  ) {
+    this.subscriptionId = subscriptionId;
+    this.eventName = eventName;
+    this.audioEventEmitter = audioEventEmitter;
+  }
+
+  public remove(): void {
+    this.audioEventEmitter.removeAudioEventListener(
+      this.eventName,
+      this.subscriptionId
+    );
+  }
+}

package/src/events/index.ts

@@ -0,0 +1,4 @@
+import AudioEventEmitter from './AudioEventEmitter';
+import AudioEventSubscription from './AudioEventSubscription';
+
+export { AudioEventEmitter, AudioEventSubscription };

package/src/events/types.ts

@@ -0,0 +1,64 @@
+import AudioBuffer from '../core/AudioBuffer';
+
+interface EventEmptyType {}
+
+export interface EventTypeWithValue {
+  value: number;
+}
+
+interface OnInterruptionEventType {
+  type: 'ended' | 'began';
+  shouldResume: boolean;
+}
+
+interface OnRouteChangeEventType {
+  reason: string;
+}
+
+interface SystemEvents {
+  remotePlay: EventEmptyType;
+  remotePause: EventEmptyType;
+  remoteStop: EventEmptyType;
+  remoteTogglePlayPause: EventEmptyType;
+  remoteChangePlaybackRate: EventTypeWithValue;
+  remoteNextTrack: EventEmptyType;
+  remotePreviousTrack: EventEmptyType;
+  remoteSkipForward: EventEmptyType;
+  remoteSkipBackward: EventEmptyType;
+  remoteSeekForward: EventTypeWithValue;
+  remoteSeekBackward: EventTypeWithValue;
+  remoteChangePlaybackPosition: EventTypeWithValue;
+  volumeChange: EventTypeWithValue;
+  interruption: OnInterruptionEventType;
+  routeChange: OnRouteChangeEventType;
+}
+
+export interface OnAudioReadyEventType {
+  buffer: AudioBuffer;
+  numFrames: number;
+  when: number;
+}
+
+interface AudioAPIEvents {
+  ended: EventTypeWithValue;
+  audioReady: OnAudioReadyEventType;
+  audioError: EventEmptyType; // to change
+  systemStateChanged: EventEmptyType; // to change
+}
+
+type AudioEvents = SystemEvents & AudioAPIEvents;
+
+export type SystemEventName = keyof SystemEvents;
+export type SystemEventCallback<Name extends SystemEventName> = (
+  event: SystemEvents[Name]
+) => void;
+
+export type AudioAPIEventName = keyof AudioAPIEvents;
+export type AudioAPIEventCallback<Name extends AudioAPIEventName> = (
+  event: AudioAPIEvents[Name]
+) => void;
+
+export type AudioEventName = keyof AudioEvents;
+export type AudioEventCallback<Name extends AudioEventName> = (
+  event: AudioEvents[Name]
+) => void;

package/src/hooks/useSytemVolume.ts

@@ -6,11 +6,12 @@ export default function useSystemVolume() {
 
   useEffect(() => {
     AudioManager.observeVolumeChanges(true);
-    const listener = AudioManager.enableRemoteEvent('volumeChange', (e) => {
+    const listener = AudioManager.enableSystemEvent('volumeChange', (e) => {
       setVolume(parseFloat(e.value.toFixed(2)));
     });
     return () => {
       listener?.remove();
+
       AudioManager.observeVolumeChanges(false);
     };
   }, []);

package/src/interfaces.ts

@@ -4,9 +4,9 @@ import {
   OscillatorType,
   BiquadFilterType,
   ChannelCountMode,
-  AudioRecorderStatus,
   ChannelInterpretation,
 } from './types';
+import { AudioEventName, AudioEventCallback } from './events/types';
 
 export interface IBaseAudioContext {
   readonly destination: IAudioDestinationNode;
@@ -54,8 +54,8 @@ export interface IAudioNode {
   readonly channelCountMode: ChannelCountMode;
   readonly channelInterpretation: ChannelInterpretation;
 
-  connect: (node: IAudioNode) => void;
-  disconnect: (node?: IAudioNode) => void;
+  connect: (destination: IAudioNode | IAudioParam) => void;
+  disconnect: (destination?: IAudioNode | IAudioParam) => void;
 }
 
 export interface IGainNode extends IAudioNode {
@@ -85,7 +85,9 @@ export interface IAudioDestinationNode extends IAudioNode {}
 export interface IAudioScheduledSourceNode extends IAudioNode {
   start(when?: number): void;
   stop: (when: number) => void;
-  onended: (arg?: number) => void | null;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onended: string;
 }
 
 export interface IOscillatorNode extends IAudioScheduledSourceNode {
@@ -165,24 +167,21 @@ export interface IAnalyserNode extends IAudioNode {
   getByteTimeDomainData: (array: Uint8Array) => void;
 }
 
-export type IAudioReadyCallback = (
-  buffer: IAudioBuffer,
-  numFrames: number,
-  when: number
-) => void;
-
-export type IErrorCallback = (error: Error) => void;
-
-export type IStatusChangeCallback = (
-  status: AudioRecorderStatus,
-  previousStatus: AudioRecorderStatus
-) => void;
-
 export interface IAudioRecorder {
   start: () => void;
   stop: () => void;
 
-  onAudioReady: (callback: IAudioReadyCallback) => void;
-  onError: (callback: IErrorCallback) => void;
-  onStatusChange: (callback: IStatusChangeCallback) => void;
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onAudioReady: string;
+}
+
+export interface IAudioEventEmitter {
+  addAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    callback: AudioEventCallback<Name>
+  ): string;
+  removeAudioEventListener<Name extends AudioEventName>(
+    name: Name,
+    subscriptionId: string
+  ): void;
 }

package/src/specs/NativeAudioAPIModule.ts

@@ -1,7 +1,28 @@
-import { TurboModuleRegistry, TurboModule } from 'react-native';
+'use strict';
+import { TurboModuleRegistry } from 'react-native';
+import type { TurboModule } from 'react-native';
+import { PermissionStatus } from '../system/types';
 
 interface Spec extends TurboModule {
   install(): boolean;
+
+  setLockScreenInfo(info: {
+    [key: string]: string | boolean | number | undefined;
+  }): void;
+  resetLockScreenInfo(): void;
+  enableRemoteCommand(name: string, enabled: boolean): void;
+  setAudioSessionOptions(
+    category: string,
+    mode: string,
+    options: Array<string>
+  ): void;
+  getDevicePreferredSampleRate(): number;
+  observeAudioInterruptions(enabled: boolean): void;
+  observeVolumeChanges(enabled: boolean): void;
+  requestRecordingPermissions(): Promise<PermissionStatus>;
+  checkRecordingPermissions(): Promise<PermissionStatus>;
 }
 
-export default TurboModuleRegistry.get<Spec>('AudioAPIModule');
+const NativeAudioAPIModule = TurboModuleRegistry.get<Spec>('AudioAPIModule');
+
+export { NativeAudioAPIModule };

package/src/specs/index.ts

@@ -1,6 +1,4 @@
 'use strict';
+import { NativeAudioAPIModule } from './NativeAudioAPIModule';
 
-import NativeAudioAPIModule from './NativeAudioAPIModule';
-import { AudioManagerModule, eventEmitter } from './NativeAudioManagerModule';
-
-export { NativeAudioAPIModule, AudioManagerModule, eventEmitter };
+export { NativeAudioAPIModule };

package/src/system/AudioManager.ts

@@ -1,24 +1,34 @@
-import {
-  SessionOptions,
-  LockScreenInfo,
-  RemoteEventName,
-  RemoteEventCallback,
-  RemoteCommandName,
-} from './types';
-import { AudioManagerModule, eventEmitter } from '../specs';
-import { EmitterSubscription } from 'react-native';
+import { SessionOptions, LockScreenInfo, PermissionStatus } from './types';
+import { SystemEventName, SystemEventCallback } from '../events/types';
+import { NativeAudioAPIModule } from '../specs';
+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();
+}
 
 class AudioManager {
+  private readonly audioEventEmitter: AudioEventEmitter;
+  constructor() {
+    this.audioEventEmitter = new AudioEventEmitter(global.AudioEventEmitter);
+  }
+
   setLockScreenInfo(info: LockScreenInfo) {
-    AudioManagerModule.setLockScreenInfo(info);
+    NativeAudioAPIModule!.setLockScreenInfo(info);
   }
 
   resetLockScreenInfo() {
-    AudioManagerModule.resetLockScreenInfo();
+    NativeAudioAPIModule!.resetLockScreenInfo();
   }
 
   setAudioSessionOptions(options: SessionOptions) {
-    AudioManagerModule.setAudioSessionOptions(
+    NativeAudioAPIModule!.setAudioSessionOptions(
       options.iosCategory ?? '',
       options.iosMode ?? '',
       options.iosOptions ?? []
@@ -26,46 +36,37 @@ class AudioManager {
   }
 
   getDevicePreferredSampleRate(): number {
-    return AudioManagerModule.getDevicePreferredSampleRate();
+    return NativeAudioAPIModule!.getDevicePreferredSampleRate();
   }
 
   observeAudioInterruptions(enabled: boolean) {
-    AudioManagerModule.observeAudioInterruptions(enabled);
+    NativeAudioAPIModule!.observeAudioInterruptions(enabled);
   }
 
   observeVolumeChanges(enabled: boolean) {
-    AudioManagerModule.observeVolumeChanges(enabled);
+    NativeAudioAPIModule!.observeVolumeChanges(enabled);
   }
 
-  enableRemoteCommand<Name extends RemoteCommandName>(name: Name): void {
-    AudioManagerModule.enableRemoteCommand(name, true);
-  }
-
-  enableRemoteEvent<Name extends RemoteEventName>(
+  enableSystemEvent<Name extends SystemEventName>(
     name: Name,
-    callback?: RemoteEventCallback<Name>
-  ): EmitterSubscription | null {
-    let subscription = null;
-    if (!callback) {
+    callback?: SystemEventCallback<Name>,
+    enabled = true
+  ): AudioEventSubscription | null {
+    NativeAudioAPIModule!.enableRemoteCommand(name, enabled);
+
+    if (!enabled || !callback) {
       return null;
     }
-    switch (name) {
-      case 'interruption':
-        subscription = eventEmitter.addListener('onInterruption', callback);
-        break;
 
-      case 'routeChange':
-        subscription = eventEmitter.addListener('onRouteChange', callback);
-        break;
+    return this.audioEventEmitter.addAudioEventListener(name, callback);
+  }
 
-      case 'volumeChange':
-        subscription = eventEmitter.addListener('onVolumeChange', callback);
-        break;
+  async requestRecordingPermissions(): Promise<PermissionStatus> {
+    return NativeAudioAPIModule!.requestRecordingPermissions();
+  }
 
-      default:
-        console.error('Unsupported RemoteControl action:', name);
-    }
-    return subscription;
+  async checkRecordingPermissions(): Promise<PermissionStatus> {
+    return NativeAudioAPIModule!.checkRecordingPermissions();
   }
 }
 

package/src/system/types.ts

@@ -51,44 +51,4 @@ export interface LockScreenInfo extends BaseLockScreenInfo {
   elapsedTime?: number;
 }
 
-interface RemoteEmptyType {}
-
-interface RemoteControlEventType {
-  value: number;
-}
-
-interface OnInterruptionEventType {
-  type: 'ended' | 'began';
-  shouldResume: boolean;
-}
-
-interface OnRouteChangeEventType {
-  reason: string;
-}
-
-interface RemoteCommands {
-  play: RemoteEmptyType;
-  pause: RemoteEmptyType;
-  stop: RemoteEmptyType;
-  togglePlayPause: RemoteEmptyType;
-  changePlaybackRate: RemoteEmptyType;
-  nextTrack: RemoteEmptyType;
-  previousTrack: RemoteEmptyType;
-  skipForward: RemoteEmptyType;
-  skipBackward: RemoteEmptyType;
-  seekForward: RemoteEmptyType;
-  seekBackward: RemoteEmptyType;
-  changePlaybackPosition: RemoteEmptyType;
-}
-
-interface RemoteEvents {
-  volumeChange: RemoteControlEventType;
-  interruption: OnInterruptionEventType;
-  routeChange: OnRouteChangeEventType;
-}
-
-export type RemoteCommandName = keyof RemoteCommands;
-export type RemoteEventName = keyof RemoteEvents;
-export type RemoteEventCallback<Name extends RemoteEventName> = (
-  event: RemoteEvents[Name]
-) => void;
+export type PermissionStatus = 'Undetermined' | 'Denied' | 'Granted';

package/src/types.ts

@@ -45,11 +45,3 @@ export type WindowType = 'blackman' | 'hann';
 export interface AudioBufferSourceNodeOptions {
   pitchCorrection: boolean;
 }
-
-export type AudioRecorderStatus =
-  | 'idle'
-  | 'initializing'
-  | 'ready'
-  | 'running'
-  | 'stopping'
-  | 'error';

package/android/src/main/java/com/swmansion/audioapi/AudioManagerModule.kt

@@ -1,64 +0,0 @@
-package com.swmansion.audioapi
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
-import com.swmansion.audioapi.system.MediaSessionManager
-
-class AudioManagerModule(
-  reactContext: ReactApplicationContext,
-) : ReactContextBaseJavaModule(reactContext) {
-  companion object {
-    const val NAME = "AudioManagerModule"
-  }
-
-  init {
-    try {
-      System.loadLibrary("react-native-audio-api")
-    } catch (exception: UnsatisfiedLinkError) {
-      throw RuntimeException("Could not load native module AudioAPIModule", exception)
-    }
-
-    MediaSessionManager.initialize(reactContext)
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun setLockScreenInfo(info: ReadableMap?) {
-    MediaSessionManager.setLockScreenInfo(info)
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun resetLockScreenInfo() {
-    MediaSessionManager.resetLockScreenInfo()
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun enableRemoteCommand(
-    name: String,
-    enabled: Boolean,
-  ) {
-    MediaSessionManager.enableRemoteCommand(name, enabled)
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun setAudioSessionOptions(
-    category: String?,
-    mode: String?,
-    options: ReadableArray?,
-  ) {
-    // Nothing to do here
-  }
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun observeAudioInterruptions(enable: Boolean) = MediaSessionManager.observeAudioInterruptions(enable)
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  fun observeVolumeChanges(enable: Boolean) = MediaSessionManager.observeVolumeChanges(enable)
-
-  override fun getName(): String = NAME
-}

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionEventEmitter.kt

@@ -1,88 +0,0 @@
-package com.swmansion.audioapi.system
-
-import android.content.Intent
-import android.os.Build
-import androidx.core.app.NotificationManagerCompat
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
-
-class MediaSessionEventEmitter(
-  val reactContext: ReactApplicationContext,
-  val notificationId: Int,
-) {
-  fun sendEvent(
-    name: String,
-    values: Map<String, Any>?,
-  ) {
-    val data = Arguments.createMap()
-
-    if (values != null) {
-      for (value in values) {
-        when (value.value) {
-          is Double, is Float -> {
-            data.putDouble(value.key, value.value as Double)
-          }
-
-          is Boolean -> {
-            data.putBoolean(value.key, value.value as Boolean)
-          }
-
-          is Int -> {
-            data.putInt(value.key, value.value as Int)
-          }
-        }
-      }
-    }
-
-    reactContext
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit(name, data)
-  }
-
-  fun onPlay() {
-    sendEvent("onRemotePlay", null)
-  }
-
-  fun onPause() {
-    sendEvent("onRemotePause", null)
-  }
-
-  fun onStop() {
-    stopForegroundService()
-    sendEvent("onRemoteStop", null)
-  }
-
-  fun onSkipToNext() {
-    sendEvent("onRemoteNextTrack", null)
-  }
-
-  fun onSkipToPrevious() {
-    sendEvent("onRemotePreviousTrack", null)
-  }
-
-  fun onFastForward() {
-    sendEvent("onRemoteSkipForward", null)
-  }
-
-  fun onRewind() {
-    sendEvent("onRemoteSkipBackward", null)
-  }
-
-  fun onInterruption(values: Map<String, Any>) {
-    sendEvent("onInterruption", values)
-  }
-
-  fun onVolumeChange(values: Map<String, Number>) {
-    sendEvent("onVolumeChange", values)
-  }
-
-  private fun stopForegroundService() {
-    NotificationManagerCompat.from(reactContext).cancel(notificationId)
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      val myIntent =
-        Intent(reactContext, MediaNotificationManager.NotificationService::class.java)
-      reactContext.stopService(myIntent)
-    }
-  }
-}

package/android/src/oldarch/NativeAudioManagerModuleSpec.java

@@ -1,99 +0,0 @@
-
-/**
- * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
- *
- * Do not edit this file as changes may cause incorrect behavior and will be lost
- * once the code is regenerated.
- *
- * @generated by codegen project: GenerateModuleJavaSpec.js
- *
- * @nolint
- */
-
-package com.swmansion.audioapi;
-
-import com.facebook.proguard.annotations.DoNotStrip;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.turbomodule.core.interfaces.TurboModule;
-import javax.annotation.Nonnull;
-
-public abstract class NativeAudioManagerModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
-  public static final String NAME = "AudioManagerModule";
-
-  public NativeAudioManagerModuleSpec(ReactApplicationContext reactContext) {
-    super(reactContext);
-  }
-
-  @Override
-  public @Nonnull String getName() {
-    return NAME;
-  }
-
-  protected final void emitOnRemotePlay() {
-    mEventEmitterCallback.invoke("onRemotePlay");
-  }
-
-  protected final void emitOnRemotePause() {
-    mEventEmitterCallback.invoke("onRemotePause");
-  }
-
-  protected final void emitOnStop() {
-    mEventEmitterCallback.invoke("onStop");
-  }
-
-  protected final void emitOnTogglePlayPause() {
-    mEventEmitterCallback.invoke("onTogglePlayPause");
-  }
-
-  protected final void emitOnChangePlaybackRate(double value) {
-    mEventEmitterCallback.invoke("onChangePlaybackRate", value);
-  }
-
-  protected final void emitOnNextTrack() {
-    mEventEmitterCallback.invoke("onNextTrack");
-  }
-
-  protected final void emitOnPreviousTrack() {
-    mEventEmitterCallback.invoke("onPreviousTrack");
-  }
-
-  protected final void emitOnSkipForward(double value) {
-    mEventEmitterCallback.invoke("onSkipForward", value);
-  }
-
-  protected final void emitOnSkipBackward(double value) {
-    mEventEmitterCallback.invoke("onSkipBackward", value);
-  }
-
-  protected final void emitOnSeekForward() {
-    mEventEmitterCallback.invoke("onSeekForward");
-  }
-
-  protected final void emitOnSeekBackward() {
-    mEventEmitterCallback.invoke("onSeekBackward");
-  }
-
-  protected final void emitOnChangePlaybackPosition(double value) {
-    mEventEmitterCallback.invoke("onChangePlaybackPosition", value);
-  }
-
-  @ReactMethod
-  @DoNotStrip
-  public abstract void setLockScreenInfo(ReadableMap info);
-
-  @ReactMethod
-  @DoNotStrip
-  public abstract void resetLockScreenInfo();
-
-  @ReactMethod
-  @DoNotStrip
-  public abstract void setSessionOptions(String category, String mode, ReadableArray options);
-
-  @ReactMethod(isBlockingSynchronousMethod = true)
-  @DoNotStrip
-  public abstract double getDevicePreferredSampleRate();
-}