pcm-processor/src/index.ts

Processes raw PCM data from mobile device microphones/live recordings

import { PcmData, PcmProcessorConfig, RecordingResult, PcmProcessorError } from "./types";
import PcmProcessorModule from "./PcmProcessorModule";
import { EventSubscription } from "react-native";

export type PcmProcessorChangeEvent = {
  data?: PcmData;
  error?: string;
};

export function addListener(
  listener: (event: PcmProcessorChangeEvent) => void,
): EventSubscription {
  PcmProcessorModule.removeListener();
  return PcmProcessorModule.addListener("onChange", listener);
}

export function removeListener(subscription: EventSubscription): void {
  if (subscription) {
    subscription.remove();
    PcmProcessorModule.removeListener();
  }
}

export async function startCapturing(
  config?: PcmProcessorConfig,
  onData?: (event: PcmProcessorChangeEvent) => void,
  onError?: (error: string) => void,
): Promise<EventSubscription> {
  try {
    const defaultConfig: PcmProcessorConfig = {
      sampleRate: 44100,
      channels: 1,
      shouldRecordAudio: false,
      fileName: `recording_${Date.now()}`,
      fileExtension: "wav",
    };

    const mergedConfig = { ...defaultConfig, ...config };

    const subscription = addListener((event) => {
      if (event.error && onError) {
        onError(event.error);
      } else if (event.data && onData) {
        onData(event);
      }
    });

    await PcmProcessorModule.startCapturing(mergedConfig);
    return subscription;
  } catch (error) {
    const errorMessage =
      error instanceof Error ? error.message : "Unknown error occurred";
    if (onError) {
      onError(errorMessage);
    }
    throw error;
  }
}

export async function stopCapturing(): Promise<RecordingResult> {
  try {
    return await PcmProcessorModule.stopCapturing();
  } catch (error) {
    const errorMessage =
      error instanceof Error ? error.message : "Failed to stop recording";
    console.error("Error stopping PCM capturing:", error);
    return {
      error: errorMessage,
    };
  }
}

export function isRecordingError(
  event: PcmProcessorChangeEvent,
): event is PcmProcessorError {
  return "error" in event;
}

export function isPcmData(
  event: PcmProcessorChangeEvent,
): event is { data: PcmData } {
  return "data" in event && event.data !== undefined;
}

export { PcmData, PcmProcessorConfig, RecordingResult, PcmProcessorError } from "./types";
export { default as PcmProcessor } from "./PcmProcessorModule";

export default {
  startCapturing,
  stopCapturing,
  addListener,
  removeListener,
  isRecordingError,
  isPcmData,
};