opuslib

import Opuslib from 'opuslib';
import { Platform, PermissionsAndroid } from 'react-native';

// Request microphone permission (Android)
async function requestPermission() {
  if (Platform.OS === 'android') {
    const granted = await PermissionsAndroid.request(
      PermissionsAndroid.PERMISSIONS.RECORD_AUDIO
    );
    return granted === PermissionsAndroid.RESULTS.GRANTED;
  }
  return true; // iOS handles permissions automatically
}

// Start recording and encoding
async function startRecording() {
  // Request permission
  const hasPermission = await requestPermission();
  if (!hasPermission) {
    console.error('Microphone permission denied');
    return;
  }

  // Listen for encoded audio chunks
  const subscription = Opuslib.addListener('audioChunk', (event) => {
    const { data, timestamp, sequenceNumber } = event;
    console.log(`Received ${data.byteLength} bytes of Opus audio`);

    // Send to your backend, save to file, etc.
    // data is an ArrayBuffer containing raw Opus packets (not packets you can write to an ogg)
  });

  // Start streaming
  await Opuslib.startStreaming({
    sampleRate: 16000,      // 16 kHz
    channels: 1,            // Mono
    bitrate: 24000,         // 24 kbps
    frameSize: 20,          // 20ms frames
    packetDuration: 100,    // 100ms packets (5 frames)
  });

  console.log('Recording started!');
}

// Stop recording
async function stopRecording() {
  await Opuslib.stopStreaming();
  console.log('Recording stopped');
}

interface AudioConfig {
  sampleRate: number;               // Sample rate in Hz (8000, 16000, 24000, 48000)
  channels: number;                 // Number of channels (1 = mono, 2 = stereo)
  bitrate: number;                  // Target bitrate in bits/second (e.g., 24000)
  frameSize: number;                // Frame duration in ms (2.5, 5, 10, 20, 40, 60)
  packetDuration: number;           // Packet duration in ms (multiple of frameSize)
  framesPerCallback?: number;       // Opus frames batched per audioChunk event (default: 1)
  dredDuration?: number;            // Reserved for future DRED support (default: 0)
  enableAmplitudeEvents?: boolean;  // Enable amplitude monitoring (default: false)
  amplitudeEventInterval?: number;  // Amplitude update interval in ms (default: 16)
  enableAudioLevel?: boolean;       // Per-frame audio level (0.0-1.0) on each OpusFrame (default: false)
  saveDebugAudio?: boolean;         // Save raw PCM to a file for debugging (development only)
  iosAudioSession?: {               // iOS AVAudioSession config (iOS only; ignored elsewhere)
    category: 'record' | 'playAndRecord' | 'playback' | 'ambient';
    mode: 'default' | 'voiceChat' | 'measurement' | 'spokenAudio';
    options?: Array<'mixWithOthers' | 'defaultToSpeaker' | 'allowBluetooth' | 'allowAirPlay' | 'allowBluetoothA2DP'>;
  };
}

{
  sampleRate: 16000,     // 16 kHz - optimal for speech
  channels: 1,           // Mono - sufficient for voice
  bitrate: 24000,        // 24 kbps - excellent quality
  frameSize: 20,         // 20ms - standard for real-time
  packetDuration: 100,   // 100ms - good balance of latency/efficiency
}

Opuslib.addListener('audioChunk', (event: AudioChunkEvent) => {
  // event.data: ArrayBuffer - First frame's Opus packet (back-compat; = frames[0].data)
  // event.frames: OpusFrame[] - Independent Opus packets (one per encoded frame)
  // event.timestamp: number - Capture timestamp in milliseconds
  // event.sequenceNumber: number - Event sequence number (starts at 0)
  // event.duration: number - Total duration in ms (frameSize * frameCount)
  // event.frameCount: number - Number of frames in this event

  // Each frame is an independent, decodable Opus packet:
  for (const frame of event.frames) {
    websocket.send(frame.data);
    // frame.audioLevel?: number - present only when enableAudioLevel is true
  }
});

interface OpusFrame {
  data: ArrayBuffer;         // Independent Opus packet (one opus_encode() output, own TOC byte)
  audioLevel?: number;       // Per-frame level 0.0-1.0 (only when enableAudioLevel is true)
}

interface AudioChunkEvent {
  data: ArrayBuffer;         // First frame's packet — kept for backward compatibility (= frames[0].data)
  frames: OpusFrame[];       // Independent Opus packets (single entry unless framesPerCallback > 1)
  timestamp: number;         // Milliseconds since epoch
  sequenceNumber: number;    // Incrementing event counter
  duration: number;          // Total duration in ms (frameSize * frameCount)
  frameCount: number;        // Number of Opus frames (= frames.length)
}

Opuslib.addAudioStartedListener((event: AudioStartedEvent) => {
  console.log(`Started: ${event.sampleRate}Hz, preSkip=${event.preSkip}`);
});
// or: Opuslib.addListener('audioStarted', (event) => { ... })

interface AudioStartedEvent {
  timestamp: number;   // Milliseconds since epoch
  sampleRate: number;  // Actual sample rate in Hz
  channels: number;    // Number of channels
  bitrate: number;     // Configured bitrate in bits/second
  frameSize: number;   // Frame duration in milliseconds
  preSkip: number;     // Encoder lookahead in samples (decoder should skip these)
}

Opuslib.addAudioEndListener((event: AudioEndEvent) => {
  console.log(`Ended: ${event.totalDuration}ms, ${event.totalPackets} packets`);
});
// or: Opuslib.addListener('audioEnd', (event) => { ... })

interface AudioEndEvent {
  timestamp: number;       // Milliseconds since epoch
  totalDuration: number;   // Total session duration in milliseconds
  totalPackets: number;    // Total audioChunk events emitted during the session
}

Opuslib.addAmplitudeListener((event: AmplitudeEvent) => {
  // event.rms: number - Root mean square amplitude (0.0 - 1.0)
  // event.peak: number - Peak amplitude (0.0 - 1.0)
  // event.timestamp: number - Milliseconds since epoch
});

interface AmplitudeEvent {
  rms: number;       // RMS amplitude (useful for average volume)
  peak: number;      // Peak amplitude (useful for clipping detection)
  timestamp: number; // Milliseconds since epoch
}

Opuslib.addErrorListener((event: ErrorEvent) => {
  console.error(`Error: ${event.message}`);
});

interface ErrorEvent {
  code: string;      // Error code (e.g., "AUDIO_RECORD_ERROR")
  message: string;   // Human-readable error message
}

import { PermissionsAndroid, Platform } from 'react-native';

if (Platform.OS === 'android') {
  await PermissionsAndroid.request(
    PermissionsAndroid.PERMISSIONS.RECORD_AUDIO
  );
}