### Audio Visualization Setup

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

This example shows the basic setup for audio visualization. It involves starting the recorder and listening for recording events to process audio data for visualization.

```typescript
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

const audioRecorderPlayer = new AudioRecorderPlayer();

const startVisualization = async () => {
  try {
    const path = await audioRecorderPlayer.startRecorder();
    audioRecorderPlayer.addRecordBackListener((e) => {
      // Process e.current_position and potentially audio data chunks
      // for visualization purposes.
      console.log('Recording for visualization:', e);
    });
    console.log('Visualization started, recording path:', path);
  } catch (error) {
    console.error('Error starting visualization:', error);
  }
};
```

--------------------------------

### Complete Audio Initialization Example (TypeScript)

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/functions.md

A comprehensive example demonstrating the full initialization process, including checking input availability, configuring the system, setting up input streams and players, and starting recording.

```typescript
import {
  configAudioSystem,
  getInputAvailable,
  InputAudioStream,
  SamplePlayer,
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
} from "@dr.pogodin/react-native-audio";

async function initializeCompleteAudioSetup() {
  // 1. Check if input is available
  const hasInput = await getInputAvailable();
  if (!hasInput) {
    throw new Error("No audio input available");
  }
  
  // 2. Configure audio system
  await configAudioSystem();
  
  // 3. Create and setup input stream
  const stream = new InputAudioStream(
    AUDIO_SOURCES.RAW,
    44100,
    CHANNEL_CONFIGS.MONO,
    AUDIO_FORMATS.PCM_16BIT,
    4096,
  );
  
  stream.addErrorListener((error) => {
    console.error("Stream error:", error);
  });
  
  stream.addChunkListener((chunk, chunkId) => {
    console.log(`Received chunk ${chunkId}`);
  });
  
  // 4. Create and setup player
  const player = new SamplePlayer();
  player.addErrorListener((error) => {
    console.error("Player error:", error);
  });
  
  // 5. Start recording
  const started = await stream.start();
  if (!started) {
    throw new Error("Failed to start stream");
  }
  
  return { stream, player };
}
```

--------------------------------

### Complete Initialization Example

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

Provides a comprehensive example of initializing the audio library, including setting up configuration options and preparing for recording or playback.

```typescript
import AudioRecorderPlayer, { AudioSetOptions } from 'react-native-audio-recorder-player';

const initializeAudio = async () => {
  const audioRecorderPlayer = new AudioRecorderPlayer();

  const audioSetOptions: AudioSetOptions = {
    // Example options, adjust as needed
    numberOfChannels: 1,
    sampleRate: 44100,
    bitRate: 128000,
    encoding: 'aac',
    wavFile: 'sample.wav' // Optional: specify a default WAV file name
  };

  try {
    const result = await audioRecorderPlayer.setAudioSet(audioSetOptions);
    console.log('Audio set options applied:', result);
    // Now the library is configured and ready for operations
    return audioRecorderPlayer;
  } catch (error) {
    console.error('Error initializing audio:', error);
    return null;
  }
};

// To use:
// initializeAudio().then(player => {
//   if (player) {
//     // Proceed with recording or playback
//   }
// });
```

--------------------------------

### Install react-native-audio and peer dependencies

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Use this command to install the library and its required peer dependencies. Ensure you have followed the react-native-permissions setup for audio recording permissions.

```sh
npx install-peerdeps @dr.pogodin/react-native-audio
```

--------------------------------

### Complete Audio Initialization and Usage Example

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/exports.md

An example demonstrating how to initialize the audio system, set up an InputAudioStream for recording, and use a SamplePlayer for playback. Includes error handling and platform-specific path adjustments for Catalyst.

```typescript
import {
  InputAudioStream,
  SamplePlayer,
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  configAudioSystem,
  getInputAvailable,
  IS_MAC_CATALYST,
} from "@dr.pogodin/react-native-audio";

async function initializeAudio() {
  // Check for input availability
  const hasInput = await getInputAvailable();
  if (!hasInput) {
    console.error("No audio input available");
    return;
  }
  
  // Configure audio system
  await configAudioSystem();
  
  // Create stream
  const stream = new InputAudioStream(
    AUDIO_SOURCES.RAW,
    44100,
    CHANNEL_CONFIGS.MONO,
    AUDIO_FORMATS.PCM_16BIT,
    4096,
  );
  
  // Setup error handling
  stream.addErrorListener((error) => {
    console.error("Stream error:", error);
  });
  
  // Setup data processing
  stream.addChunkListener((chunk, chunkId) => {
    console.log(`Received chunk ${chunkId}: ${chunk.length} bytes`);
  });
  
  // Start recording
  const started = await stream.start();
  console.log("Recording:", started ? "started" : "failed");
  
  // Create player
  const player = new SamplePlayer();
  player.addErrorListener((error) => {
    console.error("Player error:", error);
  });
  
  // Load and play sample
  if (IS_MAC_CATALYST) {
    const path = `${MainBundlePath}/Contents/Resources/assets/sample.mp3`;
    await player.load("sample", path);
  } else {
    const path = `${MainBundlePath}/sample.mp3`;
    await player.load("sample", path);
  }
  
  await player.play("sample", false);
  
  // Cleanup
  return () => {
    stream.destroy();
    player.destroy();
  };
}
```

--------------------------------

### .start()

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Starts the audio stream recording, initializing the stream on the native side. May request audio recording permission. Resolves to true if started successfully, false otherwise.

```APIDOC
## .start()

### Description
Starts the audio stream recording. This method actually initializes the stream
on the native side, and starts the recording.

**Note:** If necessary, this method will ask app user for the audio recoding
permission, using the [react-native-permissions] library.

### Method
```ts
stream.start(): Promise<boolean>;
```

### Response
#### Success Response (200)
- **boolean** - _true_ if the stream has started
  successfully and is [.active], _false_ otherwise.
```

--------------------------------

### Robust Audio Setup with Retries

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/errors.md

Implements an audio setup function that retries initialization up to three times with a one-second delay between attempts. It throws an error if setup fails after all retries.

```typescript
async function robustAudioSetup() {
  let retries = 3;
  
  while (retries > 0) {
    try {
      const stream = new InputAudioStream(
        AUDIO_SOURCES.RAW,
        44100,
        CHANNEL_CONFIGS.MONO,
        AUDIO_FORMATS.PCM_16BIT,
        4096,
      );
      
      stream.addErrorListener((error) => {
        console.error("Stream error:", error);
        // Restart on error
        this.restart();
      });
      
      const started = await stream.start();
      if (started) return stream;
      
    } catch (error) {
      console.error(`Setup attempt ${4 - retries} failed:`, error);
      retries--;
      
      if (retries > 0) {
        // Wait before retrying
        await new Promise(resolve => setTimeout(resolve, 1000));
      }
    }
  }
  
  throw new Error("Failed to setup audio after 3 attempts");
}
```

--------------------------------

### Create and Start InputAudioStream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Demonstrates how to create and configure an InputAudioStream, add listeners for errors and data chunks, and start the audio capture. Ensure to call stream.destroy() to release resources.

```javascript
import {
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  InputAudioStream,
} from "@dr.pogodin/react-native-audio";

function createAndStartAudioStream() {
  const stream = new InputAudioStream(
    AUDIO_SOURCES.RAW,
    44100, // Sample rate in Hz.
    CHANNEL_CONFIGS.MONO,
    AUDIO_FORMATS.PCM_16BIT,
    4096, // Sampling size.
  );

  stream.addErrorListener((error) => {
    // Do something with a stream error.
  });

  stream.addChunkListener((chunk, chunkId) => {
    // Pause the stream for the chunk processing. The point is: if your chunk
    // processing in this function is too slow, and chunks arrive faster than
    // this callback is able to handle them, it will rapidly crash the app,
    // with out of memory error. Muting the stream ignores any new chunks
    // until stream.unmute() is called, thus protecting from the crash.
    // And if your chunk processing is rapid enough, not chunks won't be
    // skipped. The "chunkId" argument is just sequential chunk numbers,
    // by which you may judge whether any chunks have been skipped between
    // this callback calls or not.
    stream.mute();

    // Do something with the chunk.

    // Resumes the stream.
    stream.unmute();
  });

  stream.start();

  // Call stream.destroy() to stop the stream and release any associated
  // resources. If you need to temporarily stop and then resume the stream,
  // use .mute() and .unmute() methods instead.
}
```

--------------------------------

### Start Basic Audio Recording

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/README.md

Configures the audio system and starts a raw audio input stream. Handles errors and processes audio chunks in real-time.

```typescript
import {
  InputAudioStream,
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  configAudioSystem,
} from "@dr.pogodin/react-native-audio";

async function startRecording() {
  // Configure audio system
  await configAudioSystem();
  
  // Create stream
  const stream = new InputAudioStream(
    AUDIO_SOURCES.RAW,
    44100,
    CHANNEL_CONFIGS.MONO,
    AUDIO_FORMATS.PCM_16BIT,
    4096,
  );
  
  // Handle errors
  stream.addErrorListener((error) => {
    console.error("Recording error:", error);
  });
  
  // Process audio
  stream.addChunkListener((chunk, chunkId) => {
    console.log(`Chunk ${chunkId}: ${chunk.length} bytes`);
  });
  
  // Start
  const success = await stream.start();
  return success ? stream : null;
}
```

--------------------------------

### Setup Error Listeners First

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/README.md

Register error listeners on an audio stream before starting it. This ensures that any errors occurring during initialization or startup are captured and handled.

```typescript
const stream = new InputAudioStream(/* ... */);
stream.addErrorListener((error) => {
  // Handle error before starting
});
await stream.start();
```

--------------------------------

### Install React Native Audio

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/README.md

Installs the library and its peer dependencies. Ensure you have react, react-native, and react-native-permissions (>=3.8) installed.

```bash
npx install-peerdeps @dr.pogodin/react-native-audio
```

--------------------------------

### .start()

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Starts the audio stream recording. Initializes the stream on the native side and begins recording. It may request audio recording permission if necessary.

```APIDOC
## .start()

### Description
Starts the audio stream recording. This method initializes the stream on the native side and begins recording. If necessary, it requests audio recording permission from the user via the `react-native-permissions` library.

### Returns
A promise that resolves to `true` if the stream started successfully and is active, or `false` otherwise.

### Example
```typescript
const isActive = await stream.start();
if (isActive) {
  console.log("Stream started successfully");
} else {
  console.log("Failed to start stream");
}
```
```

--------------------------------

### Start Metro Bundler

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/example/README.md

Run this command from the root of your React Native project to start the Metro dev server. This is essential for the development workflow.

```sh
# Using npm
npm start

# OR using Yarn
yarn start
```

--------------------------------

### Voice Communication with Effects

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

This example outlines the setup for voice communication, potentially involving real-time audio processing and effects. The specific effects implementation would depend on additional libraries or native modules.

```typescript
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

const audioRecorderPlayer = new AudioRecorderPlayer();

// For voice communication, you would typically start recording
// and stream the audio data to a remote peer or service.
// Applying effects would happen either on the sender's side before streaming
// or on the receiver's side after receiving.

const startVoiceCommunication = async () => {
  try {
    const path = await audioRecorderPlayer.startRecorder();
    // ... logic to stream audio data and apply effects ...
    console.log('Voice communication started, recording path:', path);
  } catch (error) {
    console.error('Error starting voice communication:', error);
  }
};
```

--------------------------------

### Start Audio Stream Recording

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Initializes and starts the audio stream recording. May request user permission. Resolves to true if the stream is active, false otherwise.

```typescript
stream.start(): Promise<boolean>;
```

--------------------------------

### Start Audio Stream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Initializes the stream on the native side and begins recording. It may request audio recording permission. Returns a promise that resolves to true if the stream started successfully and is active, or false otherwise.

```typescript
const isActive = await stream.start();
if (isActive) {
  console.log("Stream started successfully");
} else {
  console.log("Failed to start stream");
}
```

--------------------------------

### Install CocoaPods Dependencies

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/example/README.md

Before running the iOS app, install CocoaPods dependencies. Run 'bundle install' once to install the bundler, and 'bundle exec pod install' after updating native dependencies.

```sh
bundle install

bundle exec pod install
```

--------------------------------

### Setting up and using InputAudioStream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Demonstrates how to initialize an InputAudioStream, add error and data listeners, start recording, and clean up the stream. Ensure to handle potential buffer overflows by muting the stream before processing chunks.

```typescript
import {
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  InputAudioStream,
} from "@dr.pogodin/react-native-audio";

function setupAudioStream() {
  const stream = new InputAudioStream(
    AUDIO_SOURCES.RAW,
    44100,
    CHANNEL_CONFIGS.MONO,
    AUDIO_FORMATS.PCM_16BIT,
    4096,
  );

  // Add error handler
  stream.addErrorListener((error) => {
    console.error("Audio error:", error.message);
  });

  // Add data handler
  stream.addChunkListener((chunk, chunkId) => {
    // Protect against buffer overflow
    stream.mute();
    
    // Process audio chunk
    const audioData = new Int16Array(chunk.buffer);
    console.log(`Chunk ${chunkId}: ${audioData.length} samples`);
    
    stream.unmute();
  });

  // Start recording
  stream.start().then((success) => {
    if (success) {
      console.log("Recording started");
    }
  });

  // Later, cleanup
  return () => {
    stream.destroy();
  };
}
```

--------------------------------

### InputAudioStream with AUDIO_FORMATS

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/types.md

Example of initializing an InputAudioStream using different AUDIO_FORMATS. Use PCM_16BIT for recommended quality or PCM_8BIT for a lower quality/size tradeoff.

```typescript
import { AUDIO_FORMATS, InputAudioStream } from "@dr.pogodin/react-native-audio";

// Use 16-bit PCM, the recommended format
const stream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT, // Recommended
  4096,
);

// Or use 8-bit for lower quality/size tradeoff
const lowQualityStream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_8BIT,
  4096,
);
```

--------------------------------

### Live Audio Visualization Stream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/README.md

This example demonstrates setting up an audio stream for live visualization. It configures a raw audio stream and uses a chunk listener to perform FFT analysis on incoming audio data, updating the visualization. The stream is muted during processing to avoid issues.

```typescript
const stream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  4096,
);

stream.addChunkListener((chunk, chunkId) => {
  stream.mute(); // Pause during processing
  
  const audioData = new Int16Array(chunk.buffer);
  const fft = performFFT(audioData);
  updateVisualization(fft);
  
  stream.unmute(); // Resume
});

await stream.start();
```

--------------------------------

### Basic Audio Recording in React Native

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

Demonstrates the fundamental setup and usage for recording audio. Ensure necessary permissions are handled before initiating recording.

```typescript
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

const audioRecorderPlayer = new AudioRecorderPlayer();

const startRecording = async () => {
  try {
    const path = await audioRecorderPlayer.startRecorder();
    audioRecorderPlayer.addRecordBackListener((e) => {
      // Handle recording progress
      return;
    });
    console.log('Recording started:', path);
  } catch (error) {
    console.error('Error starting recording:', error);
  }
};

const stopRecording = async () => {
  try {
    const result = await audioRecorderPlayer.stopRecorder();
    audioRecorderPlayer.removeRecordBackListener();
    console.log('Recording stopped:', result);
  } catch (error) {
    console.error('Error stopping recording:', error);
  }
};
```

--------------------------------

### React Native Audio Component Usage

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/EXPORTS.md

Example of using the React Native Audio library within a React component. Demonstrates setting up an audio stream, handling errors, and playing samples. Ensure all peer dependencies are installed.

```typescript
import React, { useEffect, useRef, useState } from 'react';
import { View, Button, Text } from 'react-native';
import {
  InputAudioStream,
  SamplePlayer,
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  configAudioSystem,
  getInputAvailable,
} from "@dr.pogodin/react-native-audio";

export default function AudioApp() {
  const { current: refs } = useRef({
    stream: null as InputAudioStream | null,
    player: null as SamplePlayer | null,
  });
  
  useEffect(() => {
    (async () => {
      // Configure and check availability
      await configAudioSystem();
      const available = await getInputAvailable();
      
      if (available) {
        // Create stream
        refs.stream = new InputAudioStream(
          AUDIO_SOURCES.RAW,
          44100,
          CHANNEL_CONFIGS.MONO,
          AUDIO_FORMATS.PCM_16BIT,
          4096,
        );
        
        // Add listeners
        refs.stream.addErrorListener((error) => {
          console.error("Stream error:", error);
        });
        
        refs.stream.addChunkListener((chunk, chunkId) => {
          console.log(`Chunk ${chunkId}: ${chunk.length} bytes`);
        });
        
        // Start recording
        await refs.stream.start();
      }
      
      // Create player
      refs.player = new SamplePlayer();
      refs.player.addErrorListener((error) => {
        console.error("Player error:", error);
      });
    })();
    
    return () => {
      refs.stream?.destroy();
      refs.player?.destroy();
    };
  }, [refs]);
  
  return (
    <View>
      <Text>Audio application</Text>
      <Button
        title="Play Sample"
        onPress={() => {
          refs.player?.play("sample", false);
        }}
      />
    </View>
  );
}

```

--------------------------------

### listen

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/native-module.md

Initializes and starts audio input recording on the native side for a given stream. It configures parameters like sample rate, channel configuration, and audio format.

```APIDOC
## listen()

### Description
Initializes and starts audio input recording on the native side. Audio chunks are emitted via `onAudioChunk` and errors via `onInputAudioStreamError`.

### Method
```typescript
listen(
  streamId: number,
  audioSource: number,    // Ignored on iOS
  sampleRate: number,
  channelConfig: number,
  audioFormat: number,
  samplingSize: number,
): Promise<void>
```

### Parameters
#### Path Parameters
- **streamId** (number) - Required - Unique identifier for this stream, used for subsequent communication
- **audioSource** (number) - Required - Audio source (Android-specific, ignored on iOS)
- **sampleRate** (number) - Required - Sample rate in Hz
- **channelConfig** (number) - Required - Channel configuration constant
- **audioFormat** (number) - Required - Audio format constant
- **samplingSize** (number) - Required - Number of samples per channel per chunk

### Returns
Promise that resolves when the stream is initialized and recording.

### Rejects
If initialization fails (e.g., permission denied, resource unavailable).
```

--------------------------------

### playSample

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/native-module.md

Starts playback of a loaded sample. If another sample is currently playing on the same player, it will be stopped.

```APIDOC
## playSample(playerId: number, sampleName: string, loop: boolean): Promise<void>

### Description
Starts playback of a loaded sample.

### Parameters
#### Path Parameters
- **playerId** (number) - Required - The player instance
- **sampleName** (string) - Required - Name of the sample to play
- **loop** (boolean) - Required - Whether to loop infinitely

### Returns
Promise that resolves when playback starts successfully.

### Rejects
If playback cannot start (e.g., sample not loaded).

### Behavior
Starting a new sample playback stops any previously playing sample from the same player.
```

--------------------------------

### Real-time Speech Recognition Setup

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

This snippet outlines the initialization for real-time speech recognition. Actual recognition logic would follow based on the library's specific API for streaming audio data.

```typescript
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

const audioRecorderPlayer = new AudioRecorderPlayer();

// Initialization for speech recognition would typically involve
// starting the recorder and piping its output to a recognition service.
// The exact implementation depends on the specific recognition library used.

// Example placeholder for starting recognition:
const startSpeechRecognition = async () => {
  try {
    const path = await audioRecorderPlayer.startRecorder();
    // ... logic to stream audio data to a speech recognition service ...
    console.log('Speech recognition started, recording path:', path);
  } catch (error) {
    console.error('Error starting speech recognition:', error);
  }
};
```

--------------------------------

### Basic Speech Recording Configuration

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/configuration.md

This example demonstrates a recommended configuration for basic speech recording, utilizing standard settings for sample rate, channel configuration, and audio format. It also enables automatic pausing when the app enters the background.

```typescript
import {
  InputAudioStream,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  AUDIO_FORMATS,
} from "@dr.pogodin/react-native-audio";

const stream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  4096,
  true,
);
```

--------------------------------

### InputAudioStream with AUDIO_SOURCES

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/types.md

Examples demonstrating the initialization of InputAudioStream with various AUDIO_SOURCES. Options include generic microphone input, sources optimized for voice communication with noise suppression, and sources optimized for speech recognition.

```typescript
import { AUDIO_SOURCES, InputAudioStream } from "@dr.pogodin/react-native-audio";

// Generic microphone input
const stream1 = new InputAudioStream(
  AUDIO_SOURCES.MIC,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  4096,
);

// Optimized for voice communication (includes noise suppression)
const stream2 = new InputAudioStream(
  AUDIO_SOURCES.VOICE_COMMUNICATION,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  4096,
);

// Optimized for speech recognition
const stream3 = new InputAudioStream(
  AUDIO_SOURCES.VOICE_RECOGNITION,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  4096,
);
```

--------------------------------

### Create InputAudioStream with Channel Configurations

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/types.md

Example of creating InputAudioStream instances for mono and stereo recordings. Ensure correct channel configuration is selected based on audio capture needs.

```typescript
import { CHANNEL_CONFIGS, InputAudioStream } from "@dr.pogodin/react-native-audio";

// Mono recording (single channel)
const monoStream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100,
  CHANNEL_CONFIGS.MONO, // 1 channel
  AUDIO_FORMATS.PCM_16BIT,
  4096,
);

// Stereo recording (two channels)
const stereoStream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100,
  CHANNEL_CONFIGS.STEREO, // 2 channels
  AUDIO_FORMATS.PCM_16BIT,
  4096,
);
```

--------------------------------

### Example Usage of IS_MAC_CATALYST

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/EXPORTS.md

Demonstrates how to use the IS_MAC_CATALYST constant for conditional execution of macOS-specific code.

```typescript
if (IS_MAC_CATALYST) {
  // macOS-specific code
}
```

--------------------------------

### Start Audio Input Stream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/native-module.md

Initializes and starts audio input recording. Audio chunks are emitted via `onAudioChunk` and errors via `onInputAudioStreamError`. This function is Android-specific for `audioSource`.

```typescript
listen(
  streamId: number,
  audioSource: number,
  sampleRate: number,
  channelConfig: number,
  audioFormat: number,
  samplingSize: number,
): Promise<void>
```

--------------------------------

### Check if Audio Stream Started Successfully

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/errors.md

Verify the return value of stream.start() to determine if the audio stream was activated. A false return typically indicates a permission denial.

```typescript
const started = await stream.start();
if (!started) {
  console.log("Stream failed to start (likely due to permission denial)");
}
```

--------------------------------

### Build and Run iOS App

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/example/README.md

Run this command in a new terminal from your project root to build and run the iOS application. Ensure Metro is running and CocoaPods dependencies are installed.

```sh
# Using npm
npm run ios

# OR using Yarn
yarn ios
```

--------------------------------

### Handle Playback Start Error

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/errors.md

Catch errors when `.play()` is called for a sample that has not been loaded or when the native player is not ready. The promise returned by `.play()` will reject.

```typescript
try {
  // This will fail if the sample was not loaded first
  await player.play("nonexistent", false);
} catch (error) {
  console.error("Playback failed:", error.message);
}
```

--------------------------------

### High-Quality Stereo Recording Configuration

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/configuration.md

This example sets up a high-quality stereo recording with a higher sample rate and the PCM_FLOAT audio format. It uses larger sampling sizes to accommodate the increased data.

```typescript
const stream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  48000,
  CHANNEL_CONFIGS.STEREO,
  AUDIO_FORMATS.PCM_FLOAT,
  8192,
  true,
);
```

--------------------------------

### player.play(sampleName, loop)

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/SamplePlayer.md

Plays a sample that was previously loaded with `.load()`. Starting playback always stops any ongoing playback from the same player. The function resolves when playback begins.

```APIDOC
## .play(sampleName, loop)

### Description
Plays a sample that was previously loaded with `.load()`. Starting playback always stops any ongoing playback from the same player. The function resolves when playback begins; for playback completion or runtime errors during playback, use `.addErrorListener()`.

### Parameters
#### Path Parameters
- **sampleName** (string) - Required - The name of the sample to play, as specified when loading it.
- **loop** (boolean) - Required - If `true`, the sample loops infinitely. If `false`, the sample plays once.

### Returns
A promise that resolves when playback starts successfully. Rejects if the sample is not loaded or playback fails to start.

### Note
In the current implementation, only one sample can play at a time per player. Starting a new sample playback automatically stops any previously playing sample from the same player. There is no technical barrier to supporting simultaneous playback of multiple samples; this is a limitation of the current implementation.

### Example
```typescript
// Load a sample
await player.load("bgm", "/path/to/background.mp3");

// Play once
await player.play("bgm", false);

// Or loop indefinitely
await player.play("bgm", true);
```
```

--------------------------------

### Voice Communication with Audio Effects

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/README.md

This example sets up an audio stream for voice communication with real-time audio effects. It configures the stream for lower latency and background operation. The chunk listener applies effects like echo and noise gate before sending audio data to a peer or saving it.

```typescript
const stream = new InputAudioStream(
  AUDIO_SOURCES.VOICE_COMMUNICATION,
  44100,
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  2048, // Lower latency for real-time
  false, // Continue in background
);

stream.addChunkListener((chunk, chunkId) => {
  stream.mute();
  
  // Apply audio effects
  const audioData = new Int16Array(chunk.buffer);
  applyEchoEffect(audioData);
  applyNoiseGate(audioData);
  
  // Send to peer or save
  sendToRemote(audioData);
  
  stream.unmute();
});

await stream.start();
```

--------------------------------

### Play Audio Sample with SamplePlayer

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/SamplePlayer.md

Plays a previously loaded audio sample. Starting playback stops any ongoing playback from the same player. Use `.addErrorListener()` for playback completion or runtime errors.

```typescript
// Load a sample
await player.load("bgm", "/path/to/background.mp3");

// Play once
await player.play("bgm", false);

// Or loop indefinitely
await player.play("bgm", true);
```

--------------------------------

### SamplePlayer Integration with InputAudioStream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/SamplePlayer.md

Shows how to use SamplePlayer to provide audio feedback during recording with InputAudioStream. This setup plays a 'beep' sound when specific audio chunks are detected.

```typescript
import {
  InputAudioStream,
  SamplePlayer,
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
} from "@dr.pogodin/react-native-audio";

function setupRecordingWithFeedback() {
  const player = new SamplePlayer();
  const stream = new InputAudioStream(
    AUDIO_SOURCES.RAW,
    44100,
    CHANNEL_CONFIGS.MONO,
    AUDIO_FORMATS.PCM_16BIT,
    4096,
  );
  
  // Load feedback sound
  player.load("beep", "/path/to/beep.mp3").then(() => {
    stream.addChunkListener((chunk, chunkId) => {
      // Process chunk
      if (shouldPlayFeedback(chunk)) {
        player.play("beep", false); // Play beep once
      }
    });
    
    stream.start();
  });
  
  return () => {
    stream.destroy();
    player.destroy();
  };
}
```

--------------------------------

### Conditional Feature Usage based on IS_MAC_CATALYST

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/types.md

Shows how to conditionally enable features, such as using high-quality audio, based on the detected platform. This example prioritizes higher quality on macOS Catalyst due to potentially more available CPU resources.

```typescript
import { IS_MAC_CATALYST } from "@dr.pogodin/react-native-audio";

function shouldUseHighQualityAudio(): boolean {
  // Use higher quality on macOS (more CPU available)
  if (IS_MAC_CATALYST) {
    return true;
  }
  
  // Use normal quality on iOS and Android
  return false;
}
```

--------------------------------

### Load and Play Audio Samples with SamplePlayer

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/SamplePlayer.md

Demonstrates how to load an audio file with a given key, play it once, and handle potential errors. Always add an error listener before using the player and remember to destroy the instance when finished to free up native resources.

```typescript
import { SamplePlayer } from "@dr.pogodin/react-native-audio";

const player = new SamplePlayer();

// Add error listener before using
player.addErrorListener((error) => {
  console.error("Player error:", error);
});

// Load and play samples
await player.load("intro", "/path/to/intro.mp3");
await player.play("intro", false); // Play once

// Cleanup when done
await player.destroy();
```

--------------------------------

### Initialize SamplePlayer

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/configuration.md

Instantiate the SamplePlayer class. It has no constructor parameters, and all configuration is handled by subsequent load and play methods.

```typescript
const player = new SamplePlayer();
```

--------------------------------

### Basic SamplePlayer Usage

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/SamplePlayer.md

Demonstrates how to load and play audio samples with error handling and cleanup. Ensure the audio file is accessible and properly copied to the document directory.

```typescript
import { SamplePlayer } from "@dr.pogodin/react-native-audio";
import { DocumentDirectoryPath, copyFileAssets } from "@dr.pogodin/react-native-fs";

async function playAudio() {
  const player = new SamplePlayer();
  
  try {
    // Setup error handling
    player.addErrorListener((error) => {
      console.error("Audio playback error:", error);
    });
    
    // Load sample
    const samplePath = `${DocumentDirectoryPath}/notification.mp3`;
    await copyFileAssets("notification.mp3", samplePath);
    await player.load("notification", samplePath);
    
    // Play once
    await player.play("notification", false);
    
    // Or play with looping
    await player.play("notification", true);
    
    // Stop after 5 seconds
    setTimeout(() => {
      player.stop("notification");
    }, 5000);
    
  } finally {
    // Always cleanup
    await player.destroy();
  }
}
```

--------------------------------

### initSamplePlayer

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/native-module.md

Initializes a new sample player instance on the native side. This function allocates native resources for a new player.

```APIDOC
## initSamplePlayer(playerId: number): Promise<void>

### Description
Initializes a new sample player instance on the native side.

### Parameters
#### Path Parameters
- **playerId** (number) - Required - Unique identifier for this player

### Returns
Promise that resolves when the player is initialized.

### Side Effects
Native resources are allocated for the player.
```

--------------------------------

### Get Audio Format

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Read-only property holding the audio format configured for the stream.

```typescript
stream.audioFormat: AUDIO_FORMATS;
```

--------------------------------

### SamplePlayer Constructor

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Creates a new SamplePlayer instance. Remember to call .destroy() to release resources.

```APIDOC
## SamplePlayer Constructor

### Description
Creates a new [SamplePlayer] instance. Note that this creation of [SamplePlayer] instance already allocates some resources at the native side, thus to release those resources you MUST USE its [.destroy()][SamplePlayer.destroy()] method once the instance is not needed anymore.

### Method
`constructor()`

### Example
```ts
const player = new SamplePlayer();
```
```

--------------------------------

### Get Sample Rate

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Read-only property indicating the sample rate of the audio stream in Hz.

```typescript
stream.sampleRate: number;
```

--------------------------------

### .active

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Read-only property indicating if the stream is currently started and recording. True even if the stream is muted.

```APIDOC
## .active

### Description
Read-only. _true_ when the stream is [started][.start()] and recording, _false_ otherwise.

**Note:** [.active] will be _true_ for a started and [.muted] stream.

### Property
```ts
stream.active: boolean;
```
```

--------------------------------

### Get Audio Stream Format

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Read-only property indicating the audio format configured for the stream during its creation.

```typescript
stream.audioFormat: AUDIO_FORMATS
```

```typescript
console.log("Format:", stream.audioFormat);
```

--------------------------------

### .stop()

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Stops the audio stream and releases native resources, but keeps JS resources. Allows the stream instance to be started again.

```APIDOC
## .stop()

### Description
Stops the stream. Unlike the [.mute()] method, [.stop()][InputAudioStream.stop()] actually stops
the audio stream and releases its resources on the native side; however,
unlike the [.destroy()][InputAudioStream.destroy()] method, it does not release its resource in the JS
layer (_i.e._ does not drop references to all connected listeners), thus
allowing to [.start()] this stream instance again (which will technically
will init a new stream on the native side, but it will be opaque to the end
user on the JS side).

### Method
```ts
stream.stop(): Promise<void>;
```

### Response
#### Success Response (200)
- **void** - Resolves once the stream is stopped.
```

--------------------------------

### Handling File Paths for Audio

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

Demonstrates how to manage and construct file paths for storing and accessing audio recordings. This is crucial for ensuring recordings are saved and can be retrieved correctly.

```typescript
import RNFS from 'react-native-fs';

const getAudioFilePath = async (fileName: string): Promise<string> => {
  const directoryPath = RNFS.DocumentDirectoryPath;
  const filePath = `${directoryPath}/${fileName}`;

  // Ensure the directory exists (optional, RNFS usually handles this)
  try {
    await RNFS.mkdir(directoryPath);
  } catch (error) {
    // Directory might already exist
    console.warn('Directory creation warning:', error);
  }

  console.log('Audio file path:', filePath);
  return filePath;
};

// Example usage:
// getAudioFilePath('myRecording.aac').then(path => console.log(path));
```

--------------------------------

### Get Audio Source

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Read-only property indicating the audio source used by the stream. Primarily affects Android devices.

```typescript
stream.audioSource: AUDIO_SOURCES;
```

--------------------------------

### Get Audio Stream Channel Configuration

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Read-only property reflecting the channel mode (MONO or STEREO) specified when the stream was created.

```typescript
stream.channelConfig: CHANNEL_CONFIGS
```

```typescript
if (stream.channelConfig === CHANNEL_CONFIGS.STEREO) {
  console.log("Recording in stereo");
}
```

--------------------------------

### Check if Audio Stream is Active

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Read-only property indicating if the stream is currently started and recording. A muted stream is still considered active.

```typescript
stream.active: boolean
```

```typescript
if (stream.active) {
  console.log("Stream is recording");
}
```

--------------------------------

### player.load(sampleName, samplePath)

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/SamplePlayer.md

Loads an audio sample from the file system into the player. The sample is decoded immediately and stored in memory, ready for playback. If a sample with the same name already exists, it is replaced.

```APIDOC
## .load(sampleName, samplePath)

### Description
Loads an audio sample from the file system into the player. If a sample with the same name already exists, it is replaced. The sample is decoded immediately and stored in memory, ready for playback.

### Parameters
#### Path Parameters
- **sampleName** (string) - Required - Unique identifier for this sample, used in subsequent `.play()` and `.stop()` calls. If a sample with this name already exists, it will be replaced.
- **samplePath** (string) - Required - Absolute file path to the sample file. Currently, only regular files are supported. On Android, assets must be copied to regular files first before loading.

### Returns
A promise that resolves when the sample is loaded and decoded, ready for playback.

### Throws/Rejects
Rejects if the file cannot be found, decoded, or if a decoding error occurs.

### Example
```typescript
// On Android, copy asset to a regular file first
import {
  DocumentDirectoryPath,
  copyFileAssets,
} from "@dr.pogodin/react-native-fs";

await copyFileAssets("sample.mp3", `${DocumentDirectoryPath}/sample.mp3`);
await player.load("mysample", `${DocumentDirectoryPath}/sample.mp3`);

// On iOS
import { MainBundlePath } from "@dr.pogodin/react-native-fs";
await player.load("mysample", `${MainBundlePath}/sample.mp3`);
```
```

--------------------------------

### Stop Audio Stream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Stops the audio stream and releases native resources, but keeps JS resources. Allows the stream instance to be started again.

```typescript
stream.stop(): Promise<void>;
```

--------------------------------

### InputAudioStream Constructor

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/README.md

Initializes a new InputAudioStream instance. The stream does not record audio until .start() is called.

```APIDOC
## constructor()

### Description
Creates a new `InputAudioStream` instance. The newly created stream does not record audio, neither consumes resources at the native side until its `.start()` method is called.

### Parameters
- `audioSource` (AUDIO_SOURCES) - The audio source this stream will listen to. Currently, it is supported for Android only; on iOS this value is just ignored, and the stream captures audio data from the default input source of the device.
- `sampleRate` (number) - Sample rate [[Hz]]. 44100 Hz is the recommended value, as it is the only rate that is guaranteed to work on all Android (and many other) devices.
- `channelConfig` (CHANNEL_CONFIGS) - _Mono_ or _Stereo_ stream mode.
- `audioFormat` (AUDIO_FORMATS) - Audio format.
- `samplingSize` (number) - Sampling (data chunk) size, expressed as the number of samples per channel in the chunk.
- `stopInBackground` (boolean) - Optional. If _true_ (default) the stream will automatically pause itself when the app leaves the foreground, and the stream will automatically resume itself when the app returns to the foreground.
```

--------------------------------

### Add Error Listeners to Audio Components

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/types.md

Example of adding error listeners to both InputAudioStream and SamplePlayer. These listeners handle errors by logging them to the console.

```typescript
import { InputAudioStream, SamplePlayer } from "@dr.pogodin/react-native-audio";

// Error handler for InputAudioStream
const streamErrorListener: ErrorListener = (error) => {
  console.error("Stream error:", error.message);
};

stream.addErrorListener(streamErrorListener);

// Error handler for SamplePlayer
const playerErrorListener: ErrorListener = (error) => {
  console.error("Player error:", error.message);
};

player.addErrorListener(playerErrorListener);
```

--------------------------------

### Add Chunk Listener to InputAudioStream

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/types.md

Example of adding a chunk listener to an InputAudioStream. The listener receives audio data chunks and their sequential IDs.

```typescript
import { InputAudioStream } from "@dr.pogodin/react-native-audio";

const stream = new InputAudioStream(/* ... */);

// Define a chunk listener
const chunkListener: ChunkListener = (chunk, chunkId) => {
  console.log(`Chunk ${chunkId}: ${chunk.length} bytes`);
  
  // Convert to typed array for processing
  const audioData = new Int16Array(chunk.buffer);
  console.log(`Samples: ${audioData.length}`);
};

stream.addChunkListener(chunkListener);
```

--------------------------------

### Managing Multiple Audio Players

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

Shows how to initialize and control multiple independent audio players. Each player instance can manage its own audio file playback.

```typescript
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

const players = [
  new AudioRecorderPlayer(),
  new AudioRecorderPlayer(),
  new AudioRecorderPlayer()
];

const playAll = async (filePaths: string[]) => {
  if (filePaths.length !== players.length) {
    console.error('Number of file paths must match number of players.');
    return;
  }
  try {
    await Promise.all(
      players.map((player, index) => player.startPlayer(filePaths[index]))
    );
    console.log('All players started.');
  } catch (error) {
    console.error('Error playing all players:', error);
  }
};

const stopAll = async () => {
  try {
    await Promise.all(players.map(player => player.stopPlayer()));
    console.log('All players stopped.');
  } catch (error) {
    console.error('Error stopping all players:', error);
  }
};
```

--------------------------------

### Get Audio Stream Sample Rate

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Read-only property indicating the stream's sample rate in Hertz (Hz), as configured during initialization.

```typescript
stream.sampleRate: number
```

```typescript
console.log("Sample rate:", stream.sampleRate, "Hz");
```

--------------------------------

### SamplePlayer Lifecycle

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/native-module.md

Details the lifecycle events for the SamplePlayer, from initialization to resource release.

```text
1. **Create:** `new SamplePlayer()` calls `initSamplePlayer()` - Native player allocated
2. **Load:** `.load()` calls `loadSample()` - Audio decoded and stored
3. **Play:** `.play()` calls `playSample()` - Playback begins
4. **Stop:** `.stop()` calls `stopSample()` - Playback stops
5. **Unload:** `.unload()` calls `unloadSample()` - Sample removed from memory
6. **Destroy:** `.destroy()` calls `destroySamplePlayer()` - All resources released
```

--------------------------------

### Create InputAudioStream Instance

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Instantiates a new InputAudioStream. The stream does not actively record until .start() is called. Ensure correct parameters for audio source, sample rate, channel configuration, audio format, and sampling size.

```typescript
import {
  AUDIO_FORMATS,
  AUDIO_SOURCES,
  CHANNEL_CONFIGS,
  InputAudioStream,
} from "@dr.pogodin/react-native-audio";

const stream = new InputAudioStream(
  AUDIO_SOURCES.RAW,
  44100, // Sample rate in Hz
  CHANNEL_CONFIGS.MONO,
  AUDIO_FORMATS.PCM_16BIT,
  4096, // Sampling size
  true, // Stop in background
);
```

--------------------------------

### Get Audio Stream Source

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/api-reference/InputAudioStream.md

Read-only property holding the audio source value provided during stream initialization. This primarily affects behavior on Android.

```typescript
stream.audioSource: AUDIO_SOURCES
```

```typescript
console.log("Source:", stream.audioSource);
```

--------------------------------

### Get Native Module Instance

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/native-module.md

Retrieves the native module instance for 'ReactNativeAudio' using TurboModuleRegistry. This is the entry point for interacting with the native module from JavaScript.

```typescript
const ReactNativeAudio = TurboModuleRegistry.getEnforcing<Spec>('ReactNativeAudio');
```

--------------------------------

### Basic Audio Playback in React Native

Source: https://github.com/birdofpreyru/react-native-audio/blob/master/_autodocs/_COMPLETION_REPORT.txt

Illustrates how to play back recorded audio files. This requires a valid file path obtained from a previous recording session.

```typescript
import AudioRecorderPlayer from 'react-native-audio-recorder-player';

const audioRecorderPlayer = new AudioRecorderPlayer();

const startPlayback = async (filePath: string) => {
  try {
    await audioRecorderPlayer.startPlayer(filePath);
    audioRecorderPlayer.addPlayBackListener((e) => {
      // Handle playback progress
      return;
    });
    console.log('Playback started');
  } catch (error) {
    console.error('Error starting playback:', error);
  }
};

const stopPlayback = async () => {
  try {
    await audioRecorderPlayer.stopPlayer();
    audioRecorderPlayer.removePlayBackListener();
    console.log('Playback stopped');
  } catch (error) {
    console.error('Error stopping playback:', error);
  }
};
```