import { AudioInput } from 'cordova-plugin-audioinput';

// Initialize with configuration
await AudioInput.initialize({
  sampleRate: 44100,
  bufferSize: 16384,
  channels: 1,
  format: 'PCM_16BIT',
  normalize: true
});

// Check/request microphone permission
const { granted } = await AudioInput.checkMicrophonePermission();
if (!granted) {
  await AudioInput.getMicrophonePermission();
}

// Listen for audio data
AudioInput.addListener('audioData', (event) => {
  console.log(`Received ${event.data.length} samples`);
  // Process audio data...
});

// Start capturing
await AudioInput.start({
  sampleRate: 44100,
  bufferSize: 16384
});

// Stop capturing
await AudioInput.stop();

import { AudioInput } from 'cordova-plugin-audioinput';

async function setupWebAudio() {
  // Request permission
  const { granted } = await AudioInput.getMicrophonePermission();
  if (!granted) return;

  // Start with Web Audio integration
  // Note: For Capacitor, use the Cordova API via window.audioinput for streamToWebAudio
  const audioinput = (window as any).audioinput;

  audioinput.start({
    streamToWebAudio: true
  });

  // Connect to speakers to hear the captured audio
  audioinput.connect(audioinput.getAudioContext().destination);
}

import { AudioInput } from 'cordova-plugin-audioinput';

async function setupRawAudio() {
  // Request permission
  await AudioInput.getMicrophonePermission();

  // Listen for audio data
  AudioInput.addListener('audioData', (event) => {
    // event.data is an array of audio samples
    processAudioData(event.data);
  });

  // Listen for errors
  AudioInput.addListener('audioError', (event) => {
    console.error('Audio error:', event.message);
  });

  // Start capturing
  await AudioInput.start({
    sampleRate: 44100,
    bufferSize: 8192,
    channels: 1,
    format: 'PCM_16BIT',
    normalize: true
  });
}

function processAudioData(samples: number[]) {
  // Your audio processing logic here
  console.log(`Processing ${samples.length} samples`);
}

// Stop when done
async function stopRecording() {
  await AudioInput.stop();
  await AudioInput.removeAllListeners();
}

import { AudioInput } from 'cordova-plugin-audioinput';
import { Filesystem, Directory } from '@capacitor/filesystem';

async function recordToFile() {
  await AudioInput.getMicrophonePermission();

  // Listen for recording finished event
  AudioInput.addListener('audioInputFinished', async (event) => {
    console.log('Recording saved to:', event.fileUrl);
    // File is now available at event.fileUrl
  });

  // Start recording to file
  const fileUrl = 'file:///path/to/recording.wav';
  await AudioInput.start({
    sampleRate: 16000,
    bufferSize: 8192,
    channels: 1,
    format: 'PCM_16BIT',
    fileUrl: fileUrl
  });

  // When ready to stop
  const result = await AudioInput.stop();
  console.log('Stopped, file at:', result.fileUrl);
}

interface AudioInputOptions {
  // Sample rate in Hz
  sampleRate?: number;          // Default: 44100
                                // Available: 8000, 11025, 16000, 22050, 32000, 44100, 48000

  // Buffer size in bytes (should be power of 2, <= 16384)
  bufferSize?: number;          // Default: 16384

  // Number of channels
  channels?: number;            // Default: 1 (Mono)
                                // 1 = Mono, 2 = Stereo

  // Audio format
  format?: 'PCM_16BIT' | 'PCM_8BIT';  // Default: 'PCM_16BIT'

  // Normalize audio data to -1.0 to 1.0 range
  normalize?: boolean;          // Default: true

  // Normalization factor (audio divided by this value)
  normalizationFactor?: number; // Default: 32767.0

  // Audio source type
  audioSourceType?: number;     // Default: 0 (DEFAULT)
                                // 0 = DEFAULT
                                // 1 = MIC (Android only)
                                // 5 = CAMCORDER
                                // 6 = VOICE_RECOGNITION (Android only)
                                // 7 = VOICE_COMMUNICATION
                                // 9 = UNPROCESSED

  // File URL for saving (when set, no data events are fired)
  fileUrl?: string;             // Example: 'file:///path/to/file.wav'

  // Cordova-specific options (use via window.audioinput)
  streamToWebAudio?: boolean;   // Let plugin handle Web Audio conversion
  audioContext?: AudioContext;  // Provide your own AudioContext
  concatenateMaxChunks?: number;// Chunks to merge (lower = lower latency)
}

import { SampleRate, AudioSourceType } from 'cordova-plugin-audioinput';

const config = {
  sampleRate: SampleRate.CD_AUDIO_44100Hz,
  audioSourceType: AudioSourceType.VOICE_COMMUNICATION
};

import { AudioInput } from 'cordova-plugin-audioinput';

// Initialize (optional - can also configure in start())
await AudioInput.initialize(options: AudioInputOptions): Promise<void>

// Check microphone permission (doesn't prompt user)
await AudioInput.checkMicrophonePermission(): Promise<{ granted: boolean }>

// Request microphone permission (prompts user if needed)
await AudioInput.getMicrophonePermission(): Promise<{ granted: boolean }>

// Start audio capture
await AudioInput.start(options: AudioInputOptions): Promise<void>

// Stop audio capture
await AudioInput.stop(): Promise<{ fileUrl?: string }>

// Add event listener
AudioInput.addListener(
  'audioData' | 'audioError' | 'audioInputFinished',
  callback
): PluginListenerHandle

// Remove all listeners
await AudioInput.removeAllListeners(): Promise<void>

// Capacitor example
import { AudioInput } from 'cordova-plugin-audioinput';

let silenceThreshold = 0.01;  // Adjust based on your needs
let isSpeaking = false;

AudioInput.addListener('audioData', (event) => {
  // Calculate RMS (Root Mean Square) for volume detection
  const samples = event.data;
  let sum = 0;
  for (let i = 0; i < samples.length; i++) {
    sum += samples[i] * samples[i];
  }
  const rms = Math.sqrt(sum / samples.length);

  // Detect speech
  if (rms > silenceThreshold && !isSpeaking) {
    console.log('Speech started');
    isSpeaking = true;
  } else if (rms <= silenceThreshold && isSpeaking) {
    console.log('Speech stopped');
    isSpeaking = false;
  }
});

await AudioInput.start({ normalize: true });