react-native-audio-api 0.5.7 → 0.6.0-rc.1

package/src/plugin/withAudioAPI.ts

@@ -0,0 +1,90 @@
+import {
+  AndroidConfig,
+  createRunOncePlugin,
+  ConfigPlugin,
+  withInfoPlist,
+  withAndroidManifest,
+} from '@expo/config-plugins';
+
+const pkg = require('react-native-audio-api/package.json');
+
+const withBackgroundAudio: ConfigPlugin = (config) => {
+  return withInfoPlist(config, (iosConfig) => {
+    iosConfig.modResults.UIBackgroundModes = [
+      ...Array.from(
+        new Set([...(iosConfig.modResults.UIBackgroundModes ?? []), 'audio'])
+      ),
+    ];
+
+    return iosConfig;
+  });
+};
+
+const withAndroidPermissions: ConfigPlugin<{
+  androidFSPermissions: string[];
+}> = (config, { androidFSPermissions }) => {
+  return AndroidConfig.Permissions.withPermissions(
+    config,
+    androidFSPermissions
+  );
+};
+
+const withForegroundService: ConfigPlugin<{
+  androidFSTypes: string[];
+}> = (config, { androidFSTypes }) => {
+  return withAndroidManifest(config, (mod) => {
+    const manifest = mod.modResults;
+    const mainApplication =
+      AndroidConfig.Manifest.getMainApplicationOrThrow(manifest);
+
+    const SFTypes = androidFSTypes.join('|');
+
+    const serviceElement = {
+      $: {
+        'android:name': 'system.MediaNotificationManager$NotificationService',
+        'android:stopWithTask': 'true',
+        'android:foregroundServiceType': SFTypes,
+      },
+      intentFilter: [],
+    };
+
+    if (!mainApplication.service) {
+      mainApplication.service = [];
+    }
+
+    mainApplication.service.push(serviceElement);
+
+    return mod;
+  });
+};
+
+const withAudioAPI: ConfigPlugin<{
+  iosBackgroundMode?: boolean;
+  androidForegroundService?: boolean;
+  androidFSPermissions?: string[];
+  androidFSTypes?: string[];
+}> = (
+  config,
+  {
+    iosBackgroundMode = true,
+    androidForegroundService = true,
+    androidFSPermissions = [],
+    androidFSTypes = [],
+  }
+) => {
+  if (iosBackgroundMode) {
+    config = withBackgroundAudio(config);
+  }
+  if (androidForegroundService) {
+    config = withAndroidPermissions(config, {
+      androidFSPermissions,
+    });
+    config = withForegroundService(config, {
+      androidFSTypes,
+    });
+  }
+
+  return config;
+};
+
+export default createRunOncePlugin(withAudioAPI, pkg.name, pkg.version);

package/src/specs/NativeAudioManagerModule.ts

@@ -0,0 +1,48 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const NativeAudioManagerModule = NativeModules.AudioManagerModule;
+const eventEmitter =
+  Platform.OS === 'android'
+    ? new NativeEventEmitter()
+    : new NativeEventEmitter(NativeModules.AudioManagerModule);
+
+if (!NativeAudioManagerModule || !eventEmitter) {
+  throw new Error(
+    `Failed to install react-native-audio-api: The native module could not be found.`
+  );
+}
+
+const AudioManagerModule = {
+  setLockScreenInfo(info: {
+    [key: string]: string | boolean | number | undefined;
+  }): void {
+    NativeAudioManagerModule.setLockScreenInfo(info);
+  },
+  resetLockScreenInfo(): void {
+    NativeAudioManagerModule.resetLockScreenInfo();
+  },
+  enableRemoteCommand(name: string, enabled: boolean): void {
+    NativeAudioManagerModule.enableRemoteCommand(name, enabled);
+  },
+  setAudioSessionOptions(
+    category: string,
+    mode: string,
+    options: Array<string>,
+    active: boolean
+  ): void {
+    NativeAudioManagerModule.setAudioSessionOptions(
+      category,
+      mode,
+      options,
+      active
+    );
+  },
+  getDevicePreferredSampleRate(): number {
+    return NativeAudioManagerModule.getDevicePreferredSampleRate();
+  },
+  observeAudioInterruptions(enabled: boolean): void {
+    NativeAudioManagerModule.observeAudioInterruptions(enabled);
+  },
+};
+
+export { eventEmitter, AudioManagerModule };

package/src/specs/index.ts

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

package/src/system/AudioManager.ts

@@ -0,0 +1,149 @@
+import {
+  SessionOptions,
+  LockScreenInfo,
+  RemoteControlEventName,
+  InterruptionEventName,
+  RemoteControlEmptyEventType,
+  RemoteControlEventType,
+  OnInterruptionEventType,
+  OnRouteChangeEventType,
+} from './types';
+import { AudioManagerModule, eventEmitter } from '../specs';
+import { EmitterSubscription } from 'react-native';
+
+type AudioManagerEventType =
+  | RemoteControlEmptyEventType
+  | RemoteControlEventType
+  | OnInterruptionEventType
+  | OnRouteChangeEventType;
+
+class AudioManager {
+  setLockScreenInfo(info: LockScreenInfo) {
+    AudioManagerModule.setLockScreenInfo(info);
+  }
+
+  resetLockScreenInfo() {
+    AudioManagerModule.resetLockScreenInfo();
+  }
+
+  setAudioSessionOptions(options: SessionOptions) {
+    AudioManagerModule.setAudioSessionOptions(
+      options.iosCategory ?? '',
+      options.iosMode ?? '',
+      options.iosOptions ?? [],
+      options.active ?? true
+    );
+  }
+
+  getDevicePreferredSampleRate(): number {
+    return AudioManagerModule.getDevicePreferredSampleRate();
+  }
+
+  observeAudioInterruptions(enabled: boolean) {
+    AudioManagerModule.observeAudioInterruptions(enabled);
+  }
+
+  enableRemoteCommand(
+    name: RemoteControlEventName | InterruptionEventName,
+    enabled: boolean,
+    callback?: (event: AudioManagerEventType) => void
+  ): EmitterSubscription | null {
+    AudioManagerModule.enableRemoteCommand(name, enabled);
+
+    let subscription = null;
+
+    if (enabled && callback) {
+      switch (name) {
+        case 'play':
+          subscription = eventEmitter.addListener('onRemotePlay', callback);
+          break;
+
+        case 'pause':
+          subscription = eventEmitter.addListener('onRemotePause', callback);
+          break;
+
+        case 'stop':
+          subscription = eventEmitter.addListener('onRemoteStop', callback);
+          break;
+
+        case 'togglePlayPause':
+          subscription = eventEmitter.addListener(
+            'onRemoteTogglePlayPause',
+            callback
+          );
+          break;
+
+        case 'changePlaybackRate':
+          subscription = eventEmitter.addListener(
+            'onRemoteChangePlaybackRate',
+            callback
+          );
+          break;
+
+        case 'nextTrack':
+          subscription = eventEmitter.addListener(
+            'onRemoteNextTrack',
+            callback
+          );
+          break;
+
+        case 'previousTrack':
+          subscription = eventEmitter.addListener(
+            'onRemotePreviousTrack',
+            callback
+          );
+          break;
+
+        case 'skipForward':
+          subscription = eventEmitter.addListener(
+            'onRemoteSkipForward',
+            callback
+          );
+          break;
+
+        case 'skipBackward':
+          subscription = eventEmitter.addListener(
+            'onRemoteSkipBackward',
+            callback
+          );
+          break;
+
+        case 'seekForward':
+          subscription = eventEmitter.addListener(
+            'onRemoteSeekForward',
+            callback
+          );
+          break;
+
+        case 'seekBackward':
+          subscription = eventEmitter.addListener(
+            'onRemoteSeekBackward',
+            callback
+          );
+          break;
+
+        case 'changePlaybackPosition':
+          subscription = eventEmitter.addListener(
+            'onRemoteChangePlaybackPosition',
+            callback
+          );
+          break;
+
+        case 'interruption':
+          subscription = eventEmitter.addListener('onInterruption', callback);
+          break;
+
+        case 'routeChange':
+          subscription = eventEmitter.addListener('onRouteChange', callback);
+          break;
+
+        default:
+          console.error('Unsupported RemoteControl action:', name);
+      }
+    }
+
+    return subscription;
+  }
+}
+
+export default new AudioManager();

package/src/system/index.ts

@@ -0,0 +1 @@
+export { default } from './AudioManager';

package/src/system/types.ts

@@ -0,0 +1,84 @@
+export type IOSCategory =
+  | 'record'
+  | 'ambient'
+  | 'playback'
+  | 'multiRoute'
+  | 'soloAmbient'
+  | 'playAndRecord';
+
+export type IOSMode =
+  | 'default'
+  | 'gameChat'
+  | 'videoChat'
+  | 'voiceChat'
+  | 'measurement'
+  | 'voicePrompt'
+  | 'spokenAudio'
+  | 'moviePlayback'
+  | 'videoRecording';
+
+export type IOSOption =
+  | 'duckOthers'
+  | 'allowAirPlay'
+  | 'mixWithOthers'
+  | 'allowBluetooth'
+  | 'defaultToSpeaker'
+  | 'allowBluetoothA2DP'
+  | 'overrideMutedMicrophoneInterruption'
+  | 'interruptSpokenAudioAndMixWithOthers';
+
+export interface SessionOptions {
+  iosMode?: IOSMode;
+  iosOptions?: IOSOption[];
+  iosCategory?: IOSCategory;
+  active?: 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 RemoteControlEventName =
+  | 'play'
+  | 'pause'
+  | 'stop'
+  | 'togglePlayPause'
+  | 'changePlaybackRate'
+  | 'nextTrack'
+  | 'previousTrack'
+  | 'skipForward'
+  | 'skipBackward'
+  | 'seekForward'
+  | 'seekBackward'
+  | 'changePlaybackPosition';
+
+export type InterruptionEventName = 'interruption' | 'routeChange';
+
+export interface RemoteControlEmptyEventType {}
+
+export interface RemoteControlEventType {
+  value: number;
+}
+
+export interface OnInterruptionEventType {
+  type: 'ended' | 'began';
+  shouldResume: boolean;
+}
+
+export interface OnRouteChangeEventType {
+  reason: string;
+}