diff --git a/apps/fabric-example/.eslintrc.js b/apps/common-app/.eslintrc.js
similarity index 100%
rename from apps/fabric-example/.eslintrc.js
rename to apps/common-app/.eslintrc.js
diff --git a/apps/common-app/package.json b/apps/common-app/package.json
index 14088516d..005d8fe6a 100644
--- a/apps/common-app/package.json
+++ b/apps/common-app/package.json
@@ -41,6 +41,6 @@
     "react": "19.1.1",
     "react-native": "0.82.0",
     "react-test-renderer": "19.1.1",
-    "typescript": "5.8.3"
+    "typescript": "~5.8.3"
   }
 }
diff --git a/apps/common-app/prettier.config.js b/apps/common-app/prettier.config.js
new file mode 100644
index 000000000..4e6d1badd
--- /dev/null
+++ b/apps/common-app/prettier.config.js
@@ -0,0 +1,10 @@
+/** @type {import('prettier').Config} */
+module.exports = {
+  plugins: ["prettier-plugin-jsdoc"],
+  bracketSameLine: false,
+  printWidth: 80,
+  singleQuote: true,
+  trailingComma: "es5",
+  tabWidth: 2,
+  arrowParens: "always",
+};
diff --git a/apps/common-app/src/components/BGGradient.tsx b/apps/common-app/src/components/BGGradient.tsx
index 15962e358..f3079587f 100644
--- a/apps/common-app/src/components/BGGradient.tsx
+++ b/apps/common-app/src/components/BGGradient.tsx
@@ -1,6 +1,6 @@
+import { Canvas, RadialGradient, Rect, vec } from '@shopify/react-native-skia';
 import React, { useCallback, useState } from 'react';
 import { LayoutChangeEvent, StyleSheet, View } from 'react-native';
-import { vec, Rect, Canvas, RadialGradient } from '@shopify/react-native-skia';
 
 import { colors } from '../styles';
 
@@ -19,7 +19,7 @@ const BGGradient = () => {
       <Canvas style={styles.canvas}>
         <Rect x={0} y={0} width={size.width} height={size.height}>
           <RadialGradient
-            r={size.width}
+            r={size.width / 4}
             c={vec(size.width / 2, 0)}
             colors={[colors.backgroundLight, colors.background]}
           />
diff --git a/apps/common-app/src/components/Container.tsx b/apps/common-app/src/components/Container.tsx
index 19797d5f4..ae9bb17f6 100644
--- a/apps/common-app/src/components/Container.tsx
+++ b/apps/common-app/src/components/Container.tsx
@@ -1,8 +1,7 @@
 import React, { PropsWithChildren } from 'react';
-import { SafeAreaView } from 'react-native-safe-area-context';
 import { StyleProp, StyleSheet, ViewStyle } from 'react-native';
+import { SafeAreaView } from 'react-native-safe-area-context';
 
-import BGGradient from './BGGradient';
 import { colors } from '../styles';
 
 type ContainerProps = PropsWithChildren<{
@@ -19,8 +18,13 @@ const Container: React.FC<ContainerProps> = (props) => {
   return (
     <SafeAreaView
       edges={['bottom', 'left', 'right']}
-      style={[styles.basic, centered && styles.centered, !disablePadding && styles.padding, style]}>
-      <BGGradient />
+      style={[
+        styles.basic,
+        centered && styles.centered,
+        !disablePadding && styles.padding,
+        style,
+      ]}
+    >
       {children}
     </SafeAreaView>
   );
diff --git a/apps/common-app/src/components/icons/PlayPauseIcon.tsx b/apps/common-app/src/components/icons/PlayPauseIcon.tsx
index 9bc65eefa..7259ad01e 100644
--- a/apps/common-app/src/components/icons/PlayPauseIcon.tsx
+++ b/apps/common-app/src/components/icons/PlayPauseIcon.tsx
@@ -1,6 +1,6 @@
 import React from 'react';
-import Svg, { Path, Rect } from 'react-native-svg';
 import { View } from 'react-native';
+import Svg, { Path, Rect } from 'react-native-svg';
 
 type Props = {
   isPlaying: boolean;
@@ -8,7 +8,11 @@ type Props = {
   color?: string;
 };
 
-const PlayPauseIcon: React.FC<Props> = ({ isPlaying = true, size = 48, color = '#FFFFFF' }) => {
+const PlayPauseIcon: React.FC<Props> = ({
+  isPlaying = true,
+  size = 48,
+  color = '#FFFFFF',
+}) => {
   return (
     <View>
       <Svg width={size} height={size} viewBox="0 0 64 64" fill="none">
@@ -18,10 +22,7 @@ const PlayPauseIcon: React.FC<Props> = ({ isPlaying = true, size = 48, color = '
             <Rect x="38" y="12" width="10" height="40" rx="2" fill={color} />
           </>
         ) : (
-          <Path
-            d="M18 12L52 32L18 52V12Z"
-            fill={color}
-          />
+          <Path d="M18 12L52 32L18 52V12Z" fill={color} />
         )}
       </Svg>
     </View>
diff --git a/apps/common-app/src/examples/AudioFile/AudioPlayer.ts b/apps/common-app/src/examples/AudioFile/AudioPlayer.ts
index bdeb84042..87169549e 100644
--- a/apps/common-app/src/examples/AudioFile/AudioPlayer.ts
+++ b/apps/common-app/src/examples/AudioFile/AudioPlayer.ts
@@ -1,8 +1,8 @@
-import { AudioContext, AudioManager } from 'react-native-audio-api';
 import type {
-  AudioBufferSourceNode,
   AudioBuffer,
+  AudioBufferSourceNode,
 } from 'react-native-audio-api';
+import { AudioContext, AudioManager } from 'react-native-audio-api';
 
 class AudioPlayer {
   private readonly audioContext: AudioContext;
@@ -93,7 +93,8 @@ class AudioPlayer {
   loadBuffer = async (url: string) => {
     const buffer = await fetch(url, {
       headers: {
-        'User-Agent': 'Mozilla/5.0 (Android; Mobile; rv:122.0) Gecko/122.0 Firefox/122.0',
+        'User-Agent':
+          'Mozilla/5.0 (Android; Mobile; rv:122.0) Gecko/122.0 Firefox/122.0',
       },
     })
       .then((response) => response.arrayBuffer())
diff --git a/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx b/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
index 50fefe1c6..655077030 100644
--- a/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
+++ b/apps/common-app/src/examples/AudioVisualizer/AudioVisualizer.tsx
@@ -1,15 +1,15 @@
-import React, { useState, useEffect, useRef } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
+import { ActivityIndicator, View } from 'react-native';
 import {
-  AudioContext,
   AnalyserNode,
   AudioBuffer,
   AudioBufferSourceNode,
+  AudioContext,
 } from 'react-native-audio-api';
-import { ActivityIndicator, View } from 'react-native';
 
-import FreqTimeChart from './FreqTimeChart';
-import { Container, Button } from '../../components';
+import { Button, Container } from '../../components';
 import { layout } from '../../styles';
+import FreqTimeChart from './FreqTimeChart';
 
 const FFT_SIZE = 512;
 
diff --git a/apps/common-app/src/examples/Record/ControlPanel.tsx b/apps/common-app/src/examples/Record/ControlPanel.tsx
new file mode 100644
index 000000000..7f033b82a
--- /dev/null
+++ b/apps/common-app/src/examples/Record/ControlPanel.tsx
@@ -0,0 +1,37 @@
+import React, { FC } from 'react';
+import { StyleSheet } from 'react-native';
+
+import Animated from 'react-native-reanimated';
+import PauseButton from './PauseButton';
+import RecordButton from './RecordButton';
+import { RecordingState } from './types';
+
+interface ControlPanelProps {
+  state: RecordingState;
+  onToggleState: (action: RecordingState) => void;
+}
+
+const ControlPanel: FC<ControlPanelProps> = ({ state, onToggleState }) => {
+  return (
+    <Animated.View style={styles.controlPanelView}>
+      <PauseButton
+        state={state}
+        onPress={() => {
+          onToggleState(RecordingState.Paused);
+        }}
+      />
+      <RecordButton state={state} onToggleState={onToggleState} />
+    </Animated.View>
+  );
+};
+
+export default ControlPanel;
+
+const styles = StyleSheet.create({
+  controlPanelView: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    flexDirection: 'row',
+    gap: 12,
+  },
+});
diff --git a/apps/common-app/src/examples/Record/PauseButton.tsx b/apps/common-app/src/examples/Record/PauseButton.tsx
new file mode 100644
index 000000000..af5d79e5a
--- /dev/null
+++ b/apps/common-app/src/examples/Record/PauseButton.tsx
@@ -0,0 +1,89 @@
+import React, { FC } from 'react';
+import { Pressable, StyleSheet, View } from 'react-native';
+import Animated, {
+  useAnimatedProps,
+  withSpring,
+} from 'react-native-reanimated';
+import { RecordingState } from './types';
+
+interface PauseButtonProps {
+  state: RecordingState;
+  onPress: () => void;
+}
+
+const PauseButton: FC<PauseButtonProps> = ({ state, onPress }) => (
+  <View>
+    <Pressable onPress={onPress} style={styles.pressable}>
+      {({ pressed }) => <PauseButtonInner state={state} pressed={pressed} />}
+    </Pressable>
+  </View>
+);
+
+export default PauseButton;
+
+const size = 24;
+const innerSize = size * 0.3;
+
+const PauseButtonInner: FC<{
+  pressed: boolean;
+  state: RecordingState;
+}> = ({ pressed, state }) => {
+  const leftViewStyle = useAnimatedProps(() => {
+    return {
+      transform: [
+        {
+          translateX: withSpring(pressed ? 6 : 0),
+        },
+      ],
+    };
+  });
+
+  const rightViewStyle = useAnimatedProps(() => {
+    return {
+      transform: [
+        {
+          translateX: withSpring(pressed ? -6 : 0),
+        },
+      ],
+    };
+  });
+
+  const containerStyle = useAnimatedProps(() => {
+    return {
+      transform: [
+        {
+          scale: withSpring(state === RecordingState.Recording ? 1 : 0),
+        },
+      ],
+    };
+  });
+
+  return (
+    <Animated.View style={[styles.container, containerStyle]}>
+      <Animated.View style={[styles.bar, leftViewStyle]} />
+      <Animated.View style={[styles.bar, rightViewStyle]} />
+    </Animated.View>
+  );
+};
+
+const styles = StyleSheet.create({
+  pressable: {
+    position: 'absolute',
+    left: -size,
+    top: -size / 2,
+  },
+  container: {
+    width: size,
+    height: size,
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    gap: innerSize - 2,
+  },
+  bar: {
+    width: innerSize,
+    height: size,
+    backgroundColor: '#d4d4d4',
+    borderRadius: 2,
+  },
+});
diff --git a/apps/common-app/src/examples/Record/Record.tsx b/apps/common-app/src/examples/Record/Record.tsx
index cdb09addb..871768693 100644
--- a/apps/common-app/src/examples/Record/Record.tsx
+++ b/apps/common-app/src/examples/Record/Record.tsx
@@ -1,174 +1,202 @@
-import React, { useRef, FC, useEffect } from 'react';
-import {
-  AudioContext,
-  AudioManager,
-  AudioRecorder,
-  RecorderAdapterNode,
-  AudioBufferSourceNode,
-  AudioBuffer,
-} from 'react-native-audio-api';
-
-import { Container, Button } from '../../components';
-import { View, Text } from 'react-native';
-import { colors } from '../../styles';
-
-const SAMPLE_RATE = 16000;
+import React, { FC, useCallback, useEffect, useState } from 'react';
+import { AudioContext, AudioManager } from 'react-native-audio-api';
+
+import { Alert, StyleSheet, View } from 'react-native';
+import { Container } from '../../components';
+
+import ControlPanel from './ControlPanel';
+import Recorder from './Recorder';
+import RecordingTime from './RecordingTime';
+import RecordingVisualization from './RecordingVisualization';
+import Status from './Status';
+import { RecordingState } from './types';
+
+AudioManager.setAudioSessionOptions({
+  iosCategory: 'playAndRecord',
+  iosMode: 'default',
+  iosOptions: ['defaultToSpeaker', 'allowBluetoothA2DP'],
+});
+
+const audioContext = new AudioContext({ initSuspended: true });
+
+Recorder.enableFileOutput({});
 
 const Record: FC = () => {
-  const recorderRef = useRef<AudioRecorder | null>(null);
-  const aCtxRef = useRef<AudioContext | null>(null);
-  const recorderAdapterRef = useRef<RecorderAdapterNode | null>(null);
-  const audioBuffersRef = useRef<AudioBuffer[]>([]);
-  const sourcesRef = useRef<AudioBufferSourceNode[]>([]);
+  const [state, setState] = useState<RecordingState>(RecordingState.Idle);
+  const [hasPermissions, setHasPermissions] = useState<boolean>(false);
 
-  useEffect(() => {
-    const setup = async () => {
-      try {
-        await AudioManager.requestRecordingPermissions();
-      } catch (err) {
-        console.log(err);
-        console.error('Recording permission denied', err);
+  const onStartRecording = useCallback(async () => {
+    if (state !== RecordingState.Idle) {
+      return;
+    }
+
+    setState(RecordingState.Loading);
+
+    if (!hasPermissions) {
+      const permissionStatus = await AudioManager.requestRecordingPermissions();
+
+      if (permissionStatus !== 'Granted') {
+        Alert.alert('Baka!', "Recording permissions are no't granted");
         return;
       }
-      recorderRef.current = new AudioRecorder({
-        sampleRate: SAMPLE_RATE,
-        bufferLengthInSamples: SAMPLE_RATE,
-      });
-    };
-
-    setup();
-    return () => {
-      aCtxRef.current?.close();
-      stopRecorder();
-    };
-  }, []);
 
-  const setupRecording = () => {
-    AudioManager.setAudioSessionOptions({
-      iosCategory: 'playAndRecord',
-      iosMode: 'spokenAudio',
-      iosOptions: ['defaultToSpeaker', 'allowBluetoothA2DP'],
-    });
-  };
-
-  const stopRecorder = () => {
-    if (recorderRef.current) {
-      recorderRef.current.stop();
-      console.log('Recording stopped');
-      // advised, but not required
-      AudioManager.setAudioSessionOptions({
-        iosCategory: 'playback',
-        iosMode: 'default',
-      });
-    } else {
-      console.error('AudioRecorder is not initialized');
+      setHasPermissions(true);
     }
-  };
 
-  const startEcho = () => {
-    if (!recorderRef.current) {
-      console.error('AudioContext or AudioRecorder is not initialized');
+    const success = await AudioManager.setAudioSessionActivity(true);
+
+    if (!success) {
+      Alert.alert('Error', 'Failed to activate audio session for recording.');
       return;
     }
-    setupRecording();
-
-    aCtxRef.current = new AudioContext({ sampleRate: SAMPLE_RATE });
-    recorderAdapterRef.current = aCtxRef.current.createRecorderAdapter();
-    recorderAdapterRef.current.connect(aCtxRef.current.destination);
-    recorderRef.current.connect(recorderAdapterRef.current);
-
-    recorderRef.current.start();
-    console.log('Recording started');
-    console.log('Audio context state:', aCtxRef.current.state);
-    if (aCtxRef.current.state === 'suspended') {
-      console.log('Resuming audio context');
-      aCtxRef.current.resume();
-    }
-  };
-
-  /// This stops only the recording, not the audio context
-  const stopEcho = () => {
-    stopRecorder();
-    aCtxRef.current = null;
-    recorderAdapterRef.current = null;
-  };
-
-  const startRecordReplay = () => {
-    if (!recorderRef.current) {
-      console.error('AudioRecorder is not initialized');
+
+    const result = Recorder.start();
+
+    if (result.status === 'success') {
+      setState(RecordingState.Recording);
       return;
     }
-    setupRecording();
-    audioBuffersRef.current = [];
-
-    recorderRef.current.onAudioReady((event) => {
-      const { buffer, numFrames } = event;
 
-      console.log('Audio recorder buffer ready:', buffer.duration, numFrames);
-      audioBuffersRef.current.push(buffer);
-    });
+    Alert.alert('Error', `Failed to start recording: ${result.message}`);
+    setState(RecordingState.Idle);
+  }, [state, hasPermissions]);
 
-    recorderRef.current.start();
+  const onPauseRecording = useCallback(() => {
+    Recorder.pause();
+    setState(RecordingState.Paused);
+  }, []);
 
-    setTimeout(() => {
-      stopRecorder();
-    }, 5000);
-  };
+  const onResumeRecording = useCallback(() => {
+    Recorder.resume();
+    setState(RecordingState.Recording);
+  }, []);
 
-  const stopRecordReplay = () => {
-    const aCtx = new AudioContext({ sampleRate: SAMPLE_RATE });
-    aCtxRef.current = aCtx;
+  const onStopRecording = useCallback(() => {
+    Recorder.stop();
+    setState(RecordingState.ReadyToPlay);
+  }, []);
 
-    if (aCtx.state === 'suspended') {
-      aCtx.resume();
+  const onPlayRecording = useCallback(() => {
+    if (state !== RecordingState.ReadyToPlay) {
+      return;
     }
 
-    const tNow = aCtx.currentTime;
-    let nextStartAt = tNow + 1;
-    const buffers = audioBuffersRef.current;
+    setState(RecordingState.Playing);
+  }, [state]);
+
+  const onToggleState = useCallback(
+    (action: RecordingState) => {
+      if (state === RecordingState.Paused) {
+        if (action === RecordingState.Recording) {
+          onResumeRecording();
+          return;
+        }
+      }
 
-    console.log(tNow, nextStartAt, buffers.length);
+      if (action === RecordingState.Recording) {
+        onStartRecording();
+        return;
+      }
 
-    for (let i = 0; i < buffers.length; i++) {
-      const source = aCtx.createBufferSource();
-      source.buffer = buffers[i];
+      if (action === RecordingState.Paused) {
+        onPauseRecording();
+        return;
+      }
 
-      source.connect(aCtx.destination);
-      sourcesRef.current.push(source);
+      if (action === RecordingState.Idle) {
+        if (state === RecordingState.Recording) {
+          onStopRecording();
+        } else if (state === RecordingState.Playing) {
+          setState(RecordingState.Idle);
+        }
+        return;
+      }
 
-      source.start(nextStartAt);
-      nextStartAt += buffers[i].duration;
-    }
+      if (action === RecordingState.ReadyToPlay) {
+        onStopRecording();
+        return;
+      }
+
+      if (action === RecordingState.Playing) {
+        onPlayRecording();
+      }
+    },
+    [
+      state,
+      onStartRecording,
+      onPauseRecording,
+      onStopRecording,
+      onResumeRecording,
+      onPlayRecording,
+    ]
+  );
 
-    setTimeout(
-      () => {
-        console.log('clearing data');
-        audioBuffersRef.current = [];
-        sourcesRef.current = [];
-      },
-      (nextStartAt - tNow) * 1000
-    );
-  };
+  useEffect(() => {
+    (async () => {
+      const permissionStatus = await AudioManager.checkRecordingPermissions();
+
+      if (permissionStatus === 'Granted') {
+        setHasPermissions(true);
+      }
+    })();
+  }, []);
 
   return (
-    <Container style={{ gap: 40 }}>
-      <Text style={{ color: colors.gray, fontSize: 18, textAlign: 'center' }}>
-        Sample rate: {SAMPLE_RATE}
-      </Text>
-      <View style={{ alignItems: 'center', gap: 10, paddingTop: 20 }}>
-        <Text style={{ color: colors.white, fontSize: 16 }}>Echo</Text>
-        <Button title="Start Recording" onPress={startEcho} />
-        <Button title="Stop Recording" onPress={stopEcho} />
-      </View>
-      <View style={{ alignItems: 'center', gap: 10, paddingTop: 40 }}>
-        <Text style={{ color: colors.white, fontSize: 16 }}>
-          Record & replay
-        </Text>
-        <Button title="Record for Replay" onPress={startRecordReplay} />
-        <Button title="Replay" onPress={stopRecordReplay} />
-      </View>
+    <Container disablePadding>
+      <Status state={state} />
+      <View style={styles.spacerM} />
+      <RecordingTime state={state} />
+      <View style={styles.spacerS} />
+      <RecordingVisualization state={state} />
+      <View style={styles.spacerM} />
+      <ControlPanel state={state} onToggleState={onToggleState} />
     </Container>
   );
 };
 
 export default Record;
+
+const styles = StyleSheet.create({
+  spacerM: { height: 24 },
+  spacerS: { height: 12 },
+});
+
+// const [lastOutput, setLastOutput] = useState<string | null>(null);
+// const durationStringSV = useSharedValue('00:00:00');
+
+// useEffect(() => {
+//   recorder.onError((error) => {
+//     console.error('Recorder error:', error);
+//     Alert.alert('Recorder Error', error.message);
+//   });
+
+//   return () => {
+//     recorder.clearOnError();
+//   };
+// }, []);
+
+// const onPlayOutput = useCallback(async () => {
+//   if (!lastOutput || state !== ExampleState.Idle) {
+//     return;
+//   }
+
+//   setState(ExampleState.Playing);
+
+//   await AudioManager.setAudioSessionActivity(true);
+
+//   const buffer = await audioContext.decodeAudioData(lastOutput);
+//   const source = audioContext.createBufferSource();
+//   source.buffer = buffer;
+//   source.connect(audioContext.destination);
+//   source.start();
+
+//   source.onEnded = async () => {
+//     await audioContext.suspend();
+//     await AudioManager.setAudioSessionActivity(false);
+//     setState(ExampleState.Idle);
+//   };
+
+//   if (audioContext.state === 'suspended') {
+//     await audioContext.resume();
+//   }
+// }, [lastOutput, state]);
diff --git a/apps/common-app/src/examples/Record/RecordButton.tsx b/apps/common-app/src/examples/Record/RecordButton.tsx
new file mode 100644
index 000000000..51ce84c71
--- /dev/null
+++ b/apps/common-app/src/examples/Record/RecordButton.tsx
@@ -0,0 +1,193 @@
+import React, { FC, useCallback } from 'react';
+import { Pressable, StyleSheet } from 'react-native';
+import Animated, {
+  useAnimatedProps,
+  withRepeat,
+  withSequence,
+  withSpring,
+  withTiming,
+} from 'react-native-reanimated';
+import Svg, { Path } from 'react-native-svg';
+
+import { RecordingState } from './types';
+
+interface RecordButtonProps {
+  state: RecordingState;
+  onToggleState: (action: RecordingState) => void;
+}
+
+const RecordButton: FC<RecordButtonProps> = ({ state, onToggleState }) => {
+  const onPress = useCallback(() => {
+    if ([RecordingState.Idle, RecordingState.Paused].includes(state)) {
+      onToggleState(RecordingState.Recording);
+      return;
+    }
+
+    if (state === RecordingState.Recording) {
+      onToggleState(RecordingState.ReadyToPlay);
+      return;
+    }
+
+    if (state === RecordingState.ReadyToPlay) {
+      onToggleState(RecordingState.Playing);
+      return;
+    }
+
+    if (state === RecordingState.Playing) {
+      onToggleState(RecordingState.Idle);
+    }
+  }, [onToggleState, state]);
+
+  return (
+    <Pressable onPress={onPress}>
+      {({ pressed }) => <RecordButtonInner pressed={pressed} state={state} />}
+    </Pressable>
+  );
+};
+
+export default RecordButton;
+
+type OuterStyle = {
+  borderColor: string;
+  transform: {
+    scale: number;
+  }[];
+};
+
+const RecordButtonInner: FC<{
+  pressed: boolean;
+  state: RecordingState;
+}> = ({ pressed, state }) => {
+  const outerViewStyle = useAnimatedProps((): OuterStyle => {
+    if (state === RecordingState.Loading) {
+      return {
+        borderColor: '#d4d4d4',
+        transform: [
+          {
+            scale: withRepeat(
+              withSequence(withSpring(1), withSpring(0.3)),
+              -1,
+              true
+            ),
+          },
+        ],
+      };
+    }
+
+    return {
+      borderColor: withTiming(
+        state === RecordingState.ReadyToPlay ? '#ff6259' : 'white'
+      ),
+      transform: [
+        {
+          scale: pressed ? withSpring(0.9) : withSpring(1),
+        },
+      ],
+    };
+  });
+
+  const innerViewStyle = useAnimatedProps(() => {
+    let size = 40;
+
+    if (
+      state === RecordingState.Recording ||
+      state === RecordingState.Playing
+    ) {
+      size = 32;
+    }
+
+    if (state === RecordingState.ReadyToPlay) {
+      size = 0;
+    }
+
+    const transform = (() => {
+      if (state === RecordingState.Loading) {
+        return [
+          {
+            scale: withRepeat(
+              withSequence(withSpring(1), withSpring(5)),
+              -1,
+              true
+            ),
+          },
+        ];
+      }
+
+      if (pressed) {
+        return [
+          {
+            scale: withSpring(1.6),
+          },
+        ];
+      }
+
+      return [
+        {
+          scale: withSpring(1),
+        },
+      ];
+    })();
+
+    return {
+      borderRadius:
+        state === RecordingState.Recording || state === RecordingState.Playing
+          ? withTiming(4)
+          : withTiming(20),
+      width: withTiming(size),
+      height: withTiming(size),
+      transform,
+    };
+  });
+
+  const playStyle = useAnimatedProps(() => {
+    const scale = state === RecordingState.ReadyToPlay ? 1 : 0;
+    return {
+      transform: [
+        {
+          scale: withTiming(scale),
+        },
+      ],
+    };
+  });
+
+  return (
+    <Animated.View style={[styles.innerContainer, outerViewStyle]}>
+      <Animated.View style={[styles.mainIcon, innerViewStyle]} />
+      <Animated.View style={[styles.playIconContainer, playStyle]}>
+        <Svg width={72} height={72} viewBox="0 0 24 24">
+          <Path
+            d="M10 8 L16 12 L10 16 Z"
+            fill="#d4d4d4"
+            stroke="#d4d4d4"
+            strokeWidth={4}
+            strokeLinejoin="round" // <-- rounded corners
+          />
+        </Svg>
+      </Animated.View>
+    </Animated.View>
+  );
+};
+
+const styles = StyleSheet.create({
+  innerContainer: {
+    width: 60,
+    height: 60,
+    borderRadius: 30,
+    borderWidth: 2,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  mainIcon: {
+    position: 'absolute',
+    width: 40,
+    height: 40,
+    borderRadius: 20,
+    backgroundColor: '#ff6259',
+  },
+  playIconContainer: {
+    position: 'absolute',
+    top: -8,
+    left: -8,
+    overflow: 'hidden',
+  },
+});
diff --git a/apps/common-app/src/examples/Record/Recorder.ts b/apps/common-app/src/examples/Record/Recorder.ts
new file mode 100644
index 000000000..e701e391f
--- /dev/null
+++ b/apps/common-app/src/examples/Record/Recorder.ts
@@ -0,0 +1,3 @@
+import { AudioRecorder } from 'react-native-audio-api';
+
+export default new AudioRecorder();
diff --git a/apps/common-app/src/examples/Record/RecordingTime.tsx b/apps/common-app/src/examples/Record/RecordingTime.tsx
new file mode 100644
index 000000000..3c4eb5cf2
--- /dev/null
+++ b/apps/common-app/src/examples/Record/RecordingTime.tsx
@@ -0,0 +1,75 @@
+import React, { useEffect } from 'react';
+import { StyleSheet, TextInput } from 'react-native';
+import Animated, {
+  useAnimatedProps,
+  useSharedValue,
+} from 'react-native-reanimated';
+
+import { colors } from '../../styles';
+import Recorder from './Recorder';
+import { RecordingState } from './types';
+
+const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
+
+interface RecordingTimeProps {
+  state: RecordingState;
+}
+
+const RecordingTime: React.FC<RecordingTimeProps> = ({ state }) => {
+  const durationStringSV = useSharedValue('00:00:00');
+
+  useEffect(() => {
+    if (![RecordingState.Recording, RecordingState.Paused].includes(state)) {
+      durationStringSV.value = '00:00:00';
+      return;
+    }
+
+    const interval = setInterval(() => {
+      const elapsedSeconds = Recorder.getCurrentDuration();
+
+      const minutes = Math.floor((elapsedSeconds % 3600) / 60)
+        .toString()
+        .padStart(2, '0');
+      const seconds = Math.floor(elapsedSeconds % 60)
+        .toString()
+        .padStart(2, '0');
+      const milliseconds = Math.floor((elapsedSeconds % 1) * 1000)
+        .toString()
+        .padStart(3, '0');
+
+      durationStringSV.value = `${minutes}:${seconds}:${milliseconds}`;
+    }, 100);
+    return () => {
+      clearInterval(interval);
+    };
+  }, [state, durationStringSV]);
+
+  const animatedText = useAnimatedProps(() => {
+    return {
+      text: durationStringSV.value,
+      defaultValue: '00:00:00',
+    };
+  });
+
+  return (
+    <AnimatedTextInput
+      editable={false}
+      animatedProps={animatedText}
+      style={styles.text}
+    />
+  );
+};
+
+export default RecordingTime;
+
+const styles = StyleSheet.create({
+  text: {
+    color: colors.gray,
+    fontSize: 48,
+    width: '100%',
+    textAlign: 'center',
+    fontFamily: 'courier-new',
+    fontWeight: 'bold',
+    fontVariant: ['tabular-nums'],
+  },
+});
diff --git a/apps/common-app/src/examples/Record/RecordingVisualization.tsx b/apps/common-app/src/examples/Record/RecordingVisualization.tsx
new file mode 100644
index 000000000..42866b86d
--- /dev/null
+++ b/apps/common-app/src/examples/Record/RecordingVisualization.tsx
@@ -0,0 +1,185 @@
+import {
+  Canvas,
+  Path,
+  Skia,
+  useCanvasRef,
+  useCanvasSize,
+} from '@shopify/react-native-skia';
+import React, { useEffect, useMemo } from 'react';
+import { StyleSheet, View } from 'react-native';
+import { useDerivedValue, useSharedValue } from 'react-native-reanimated';
+
+import Recorder from './Recorder';
+import { RecordingState } from './types';
+
+interface RecordingVisualizationProps {
+  state: RecordingState;
+}
+
+const constants = {
+  sampleRate: 3125,
+  updateIntervalMS: 32,
+  barWidth: 3,
+  barGap: 2,
+  minDb: -40,
+  maxDb: 0,
+} as const;
+
+class RingBuffer {
+  private data: Float64Array;
+  private head = 0;
+  private count = 0;
+
+  constructor(private readonly capacity: number) {
+    this.data = new Float64Array(capacity);
+    this.data.fill(-1);
+    this.head = capacity - 1;
+    this.count = capacity;
+  }
+
+  push(v: number) {
+    this.head = (this.head + 1) % this.capacity;
+    this.data[this.head] = v;
+
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+  }
+
+  toArray(): number[] {
+    const out = new Array<number>(this.count);
+
+    for (let i = 0; i < this.count; i++) {
+      const idx =
+        (this.head - this.count + i + this.capacity + 1) % this.capacity;
+      out[i] = this.data[idx];
+    }
+
+    return out;
+  }
+
+  clear() {
+    this.data.fill(-1);
+    this.head = 0;
+    this.count = 0;
+  }
+
+  size() {
+    return this.count;
+  }
+}
+
+const RecordingVisualization: React.FC<RecordingVisualizationProps> = ({
+  state,
+}) => {
+  const canvasRef = useCanvasRef();
+  const { size } = useCanvasSize(canvasRef);
+  const barHeights = useSharedValue<number[]>([]);
+
+  const numBars = useMemo(() => {
+    if (size.width === 0) {
+      return 0;
+    }
+
+    return Math.floor(size.width / (constants.barWidth + constants.barGap));
+  }, [size.width]);
+
+  const waveformPath = useDerivedValue(() => {
+    const path = Skia.Path.Make();
+    const currentHeights = barHeights.value;
+    const canvasHeight = size.height;
+
+    if (currentHeights.length === 0 || canvasHeight === 0) {
+      return path;
+    }
+
+    currentHeights.forEach((height, index) => {
+      if (height < 0) {
+        return;
+      }
+
+      const x =
+        index * (constants.barWidth + constants.barGap) +
+        constants.barWidth / 2;
+      const y1 = (canvasHeight - height) / 2;
+      const y2 = (canvasHeight + height) / 2;
+
+      path.moveTo(x, y1);
+      path.lineTo(x, y2);
+    });
+
+    return path;
+  }, [size, numBars]);
+
+  useEffect(() => {
+    if (numBars <= 0) {
+      return;
+    }
+
+    const ringBuffer = new RingBuffer(numBars);
+
+    Recorder.onAudioReady(
+      {
+        sampleRate: constants.sampleRate,
+        channelCount: 1,
+        bufferLength:
+          (constants.updateIntervalMS / 1000.0) * constants.sampleRate,
+      },
+      (event) => {
+        const audioData = event.buffer.getChannelData(0);
+
+        let maxValue = 0;
+        for (let i = 0; i < audioData.length; i++) {
+          if (Math.abs(audioData[i]) > maxValue) {
+            maxValue = Math.abs(audioData[i]);
+          }
+        }
+
+        const db = maxValue > 0 ? 20 * Math.log10(maxValue) : constants.minDb;
+        let normalized =
+          (db - constants.minDb) / (constants.maxDb - constants.minDb);
+        normalized = Math.max(0, Math.min(1, normalized));
+
+        ringBuffer.push(Math.pow(normalized, 2) * size.height * 0.8);
+        barHeights.value = ringBuffer.toArray();
+      }
+    );
+
+    return () => {
+      Recorder.clearOnAudioReady();
+    };
+  }, [numBars, size.height, barHeights]);
+
+  useEffect(() => {
+    if (![RecordingState.Recording, RecordingState.Paused].includes(state)) {
+      barHeights.value = Array(numBars).fill(-1);
+      return;
+    }
+  }, [state, numBars, barHeights]);
+
+  return (
+    <View style={styles.container}>
+      <Canvas style={styles.canvas} ref={canvasRef}>
+        <Path
+          path={waveformPath}
+          style="stroke"
+          strokeWidth={constants.barWidth}
+          strokeCap="round"
+          color="#ff6259"
+        />
+      </Canvas>
+    </View>
+  );
+};
+export default RecordingVisualization;
+
+const styles = StyleSheet.create({
+  container: {
+    height: 400,
+    width: '100%',
+    backgroundColor: 'rgba(0, 0, 0, 0.15)',
+  },
+  canvas: {
+    flex: 1,
+  },
+});
diff --git a/apps/common-app/src/examples/Record/Status.tsx b/apps/common-app/src/examples/Record/Status.tsx
new file mode 100644
index 000000000..afde28875
--- /dev/null
+++ b/apps/common-app/src/examples/Record/Status.tsx
@@ -0,0 +1,45 @@
+import React, { FC } from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+
+import { RecordingState } from './types';
+
+interface StatusProps {
+  state: RecordingState;
+}
+
+const Status: FC<StatusProps> = ({ state }) => {
+  let statusText = '';
+
+  if (state === RecordingState.Idle) {
+    statusText = 'Idle';
+  } else if (state === RecordingState.Loading) {
+    statusText = 'Loading...';
+  } else if (state === RecordingState.Recording) {
+    statusText = 'Recording...';
+  } else if (state === RecordingState.Paused) {
+    statusText = 'Paused';
+  } else if (state === RecordingState.ReadyToPlay) {
+    statusText = 'Ready to Play';
+  } else if (state === RecordingState.Playing) {
+    statusText = 'Playing...';
+  }
+
+  return (
+    <View style={styles.statusView}>
+      <Text style={styles.statusText}>{statusText}</Text>
+    </View>
+  );
+};
+
+export default Status;
+
+const styles = StyleSheet.create({
+  statusView: {
+    marginTop: 40,
+    alignItems: 'center',
+  },
+  statusText: {
+    fontSize: 18,
+    color: 'white',
+  },
+});
diff --git a/apps/common-app/src/examples/Record/types.ts b/apps/common-app/src/examples/Record/types.ts
new file mode 100644
index 000000000..edcf19433
--- /dev/null
+++ b/apps/common-app/src/examples/Record/types.ts
@@ -0,0 +1,8 @@
+export enum RecordingState {
+  Idle = 'Idle',
+  Loading = 'Loading',
+  Recording = 'Recording',
+  Paused = 'Paused',
+  ReadyToPlay = 'ReadyToPlay',
+  Playing = 'Playing',
+}
diff --git a/apps/common-app/src/examples/Streaming/Streaming.tsx b/apps/common-app/src/examples/Streaming/Streaming.tsx
index c776f6c13..b83009139 100644
--- a/apps/common-app/src/examples/Streaming/Streaming.tsx
+++ b/apps/common-app/src/examples/Streaming/Streaming.tsx
@@ -1,12 +1,8 @@
-import React, { useRef, FC, useEffect, act } from 'react';
-import {
-  AudioContext,
-  StreamerNode,
-  GainNode
-} from 'react-native-audio-api';
+import React, { FC, useEffect, useRef } from 'react';
+import { AudioContext, GainNode, StreamerNode } from 'react-native-audio-api';
 
-import { Container, Button } from '../../components';
 import { View } from 'react-native';
+import { Button, Container } from '../../components';
 
 const SAMPLE_RATE = 44100;
 
@@ -22,7 +18,7 @@ const Streaming: FC = () => {
     return () => {
       aCtxRef.current?.close();
       streamerRef.current?.stop();
-    }
+    };
   }, []);
 
   const startStreaming = () => {
@@ -36,7 +32,9 @@ const Streaming: FC = () => {
     }
     streamerRef.current = aCtxRef.current.createStreamer();
 
-    streamerRef.current.initialize('https://liveradio.timesa.pl/2980-1.aac/playlist.m3u8');
+    streamerRef.current.initialize(
+      'https://liveradio.timesa.pl/2980-1.aac/playlist.m3u8'
+    );
     streamerRef.current.connect(gainRef.current);
     gainRef.current.connect(aCtxRef.current.destination);
     streamerRef.current.start(aCtxRef.current.currentTime);
@@ -51,22 +49,27 @@ const Streaming: FC = () => {
     }
   };
 
-
   return (
     <Container style={{ gap: 40 }}>
       <View style={{ alignItems: 'center', justifyContent: 'center', gap: 5 }}>
         <Button title="Start streaming" onPress={startStreaming} />
         <Button title="Stop streaming" onPress={stopStreaming} />
-        <Button title="Volume to 0.5" onPress={() => {
-          if (gainRef.current) {
-            gainRef.current.gain.value = 0.5;
-          }
-        }} />
-        <Button title="Volume to 2.0" onPress={() => {
-          if (gainRef.current) {
-            gainRef.current.gain.value = 2.0;
-          }
-        }} />
+        <Button
+          title="Volume to 0.5"
+          onPress={() => {
+            if (gainRef.current) {
+              gainRef.current.gain.value = 0.5;
+            }
+          }}
+        />
+        <Button
+          title="Volume to 2.0"
+          onPress={() => {
+            if (gainRef.current) {
+              gainRef.current.gain.value = 2.0;
+            }
+          }}
+        />
       </View>
     </Container>
   );
diff --git a/apps/common-app/src/styles.ts b/apps/common-app/src/styles.ts
index 93ef9d2e2..4859f115d 100644
--- a/apps/common-app/src/styles.ts
+++ b/apps/common-app/src/styles.ts
@@ -17,9 +17,9 @@ export const colors = {
   gray: '#d7d7d7',
   yellow: '#FFD61E',
 
-  background: '#222222',
+  background: '#232736',
   backgroundDark: '#1f2020',
-  backgroundLight: '#333333',
+  backgroundLight: '#32384d',
 
   separator: '#333333',
   modalBackdrop: '#00000040',
diff --git a/apps/fabric-example/ios/FabricExample.xcodeproj/project.pbxproj b/apps/fabric-example/ios/FabricExample.xcodeproj/project.pbxproj
index d27788b05..f4da7aa34 100644
--- a/apps/fabric-example/ios/FabricExample.xcodeproj/project.pbxproj
+++ b/apps/fabric-example/ios/FabricExample.xcodeproj/project.pbxproj
@@ -274,7 +274,7 @@
 					"-ObjC",
 					"-lc++",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = "fdsfsdfsdcom-esegsefser.--PRODUCT-NAME-rfc1034identifier-";
+				PRODUCT_BUNDLE_IDENTIFIER = "fdsfsdfsdcom-eseg333er.--PRODUCT-NAME-rfc1034identifier-";
 				PRODUCT_NAME = FabricExample;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
 				SWIFT_VERSION = 5.0;
@@ -302,7 +302,7 @@
 					"-ObjC",
 					"-lc++",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = "fdsfsdfsdcom-esegsefser.--PRODUCT-NAME-rfc1034identifier-";
+				PRODUCT_BUNDLE_IDENTIFIER = "fdsfsdfsdcom-eseg333er.--PRODUCT-NAME-rfc1034identifier-";
 				PRODUCT_NAME = FabricExample;
 				SWIFT_VERSION = 5.0;
 				VERSIONING_SYSTEM = "apple-generic";
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index e0fee10bd..ec0022855 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2440,7 +2440,7 @@ PODS:
     - React-perflogger (= 0.82.0)
     - React-utils (= 0.82.0)
     - SocketRocket
-  - RNAudioAPI (0.11.0):
+  - RNAudioAPI (0.11.0-alpha.1):
     - boost
     - DoubleConversion
     - fast_float
@@ -2466,10 +2466,10 @@ PODS:
     - ReactCodegen
     - ReactCommon/turbomodule/bridging
     - ReactCommon/turbomodule/core
-    - RNAudioAPI/audioapi (= 0.11.0)
+    - RNAudioAPI/audioapi (= 0.11.0-alpha.1)
     - SocketRocket
     - Yoga
-  - RNAudioAPI/audioapi (0.11.0):
+  - RNAudioAPI/audioapi (0.11.0-alpha.1):
     - boost
     - DoubleConversion
     - fast_float
@@ -2495,11 +2495,11 @@ PODS:
     - ReactCodegen
     - ReactCommon/turbomodule/bridging
     - ReactCommon/turbomodule/core
-    - RNAudioAPI/audioapi/audioapi_dsp (= 0.11.0)
-    - RNAudioAPI/audioapi/ios (= 0.11.0)
+    - RNAudioAPI/audioapi/audioapi_dsp (= 0.11.0-alpha.1)
+    - RNAudioAPI/audioapi/ios (= 0.11.0-alpha.1)
     - SocketRocket
     - Yoga
-  - RNAudioAPI/audioapi/audioapi_dsp (0.11.0):
+  - RNAudioAPI/audioapi/audioapi_dsp (0.11.0-alpha.1):
     - boost
     - DoubleConversion
     - fast_float
@@ -2527,7 +2527,7 @@ PODS:
     - ReactCommon/turbomodule/core
     - SocketRocket
     - Yoga
-  - RNAudioAPI/audioapi/ios (0.11.0):
+  - RNAudioAPI/audioapi/ios (0.11.0-alpha.1):
     - boost
     - DoubleConversion
     - fast_float
@@ -3216,7 +3216,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: c5c4f5280e4ae0f9f4a739c64c4260fe0b3edaf1
   ReactCodegen: 096bbbb2498ca55f385e2fbd465bfa0211ee8295
   ReactCommon: 25c7f94aee74ddd93a8287756a8ac0830a309544
-  RNAudioAPI: d8a5bc076cb04272fbb9eee48d6cce69394b62c0
+  RNAudioAPI: c9d0b523eaee870f9aeadf289c8cf9815aa12033
   RNGestureHandler: f1dd7f92a0faa2868a919ab53bb9d66eb4ebfcf5
   RNReanimated: e4993dd98196c698cbacc1441a4ac5b855ae56dc
   RNScreens: 833237c48c756d40764540246a501b47dadb2cac
diff --git a/package.json b/package.json
index 128e0ebc2..9f3f37b79 100644
--- a/package.json
+++ b/package.json
@@ -19,11 +19,11 @@
     "test": "sh packages/react-native-audio-api/common/cpp/test/RunTests.sh"
   },
   "devDependencies": {
-    "@commitlint/config-conventional": "^17.0.2",
+    "@commitlint/config-conventional": "17.0.2",
     "@evilmartians/lefthook": "^1.5.0",
-    "@react-native/eslint-config": "0.81.0",
+    "@react-native/eslint-config": "0.82.0",
     "@types/raf": "^3.4.3",
-    "commitlint": "^17.0.2",
+    "commitlint": "17.0.2",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-jsdoc": "^50.2.2",
@@ -32,7 +32,10 @@
     "hermes-eslint": "^0.26.0",
     "prettier": "^3.3.3",
     "prettier-plugin-jsdoc": "^1.3.0",
-    "typescript": "5.8.3"
+    "typescript": "~5.8.3"
+  },
+  "resolutions": {
+    "typescript": "~5.8.3"
   },
   "commitlint": {
     "extends": [
@@ -72,8 +75,5 @@
     "tabWidth": 2,
     "trailingComma": "es5",
     "useTabs": false
-  },
-  "dependencies": {
-    "eslint-plugin-ft-flow": "^3.0.11"
   }
 }
diff --git a/packages/audiodocs/package.json b/packages/audiodocs/package.json
index b5fdc204f..0f212827a 100644
--- a/packages/audiodocs/package.json
+++ b/packages/audiodocs/package.json
@@ -69,7 +69,7 @@
     "eslint-plugin-mdx": "^2.2.0",
     "patch-package": "^8.0.0",
     "prettier": "^2.8.4",
-    "typescript": "~5.2.2",
+    "typescript": "~5.8.3",
     "typescript-eslint": "^8.18.0",
     "webpack-cli": "^5.0.1"
   },
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
index d174e9d57..9fd07065a 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
@@ -1,93 +1,327 @@
+#include <android/log.h>
 #include <audioapi/android/core/AndroidAudioRecorder.h>
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
+#include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
+#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
 
 namespace audioapi {
 
 AndroidAudioRecorder::AndroidAudioRecorder(
-    float sampleRate,
-    int bufferLength,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry) {
+    : AudioRecorder(audioEventHandlerRegistry) {
+  nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
+
+  streamSampleRate_ = 0;
+  streamChannelCount_ = 0;
+  streamMaxBufferSizeInFrames_ = 0;
+}
+
+AndroidAudioRecorder::~AndroidAudioRecorder() {
+  nativeAudioRecorder_.release();
+
+  if (mStream_) {
+    mStream_->requestStop();
+    mStream_->close();
+    mStream_.reset();
+  }
+}
+
+ReturnStatus<void> AndroidAudioRecorder::openAudioStream() {
+  if (mStream_) {
+    return ReturnStatus<void>::Success();
+  }
+
   AudioStreamBuilder builder;
   builder.setSharingMode(SharingMode::Exclusive)
       ->setDirection(Direction::Input)
       ->setFormat(AudioFormat::Float)
       ->setFormatConversionAllowed(true)
       ->setPerformanceMode(PerformanceMode::None)
-      ->setChannelCount(1)
       ->setSampleRateConversionQuality(SampleRateConversionQuality::Medium)
       ->setDataCallback(this)
-      ->setSampleRate(static_cast<int>(sampleRate))
-      ->openStream(mStream_);
+      ->setErrorCallback(this);
 
-  nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
+  auto result = builder.openStream(mStream_);
+
+  if (result != oboe::Result::OK || mStream_ == nullptr) {
+    return ReturnStatus<void>::Error(
+        "Failed to open audio stream: " +
+        std::string(oboe::convertToText(result)));
+  }
+
+  streamSampleRate_ = mStream_->getSampleRate();
+  streamChannelCount_ = mStream_->getChannelCount();
+  streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
+
+  return ReturnStatus<void>::Success();
 }
 
-AndroidAudioRecorder::~AndroidAudioRecorder() {
-  nativeAudioRecorder_.release();
+ReturnStatus<std::string> AndroidAudioRecorder::start() {
+  Locker callbackLock(callbackMutex_);
+  Locker fileWriterLock(fileWriterMutex_);
 
-  if (mStream_) {
-    mStream_->requestStop();
-    mStream_->close();
-    mStream_.reset();
+  if (isRecording()) {
+    return ReturnStatus<std::string>::Success(
+        std::format("file://{}", filePath_));
   }
+
+  auto streamResult = openAudioStream();
+
+  if (!streamResult.isSuccess()) {
+    return ReturnStatus<std::string>::Error(streamResult.getMessage());
+  }
+
+  if (!mStream_ || !nativeAudioRecorder_) {
+    return ReturnStatus<std::string>::Error("Audio stream is not initialized.");
+  }
+
+  if (usesFileOutput()) {
+    auto fileResult = fileWriter_->openFile(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+
+    if (!fileResult.isSuccess()) {
+      return ReturnStatus<std::string>::Error(
+          "Failed to open file for writing: " + fileResult.getMessage());
+    }
+
+    filePath_ = fileResult.getValue();
+  }
+
+  if (usesCallback()) {
+    callback_->prepare(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+  }
+
+  if (isConnected()) {
+    // TODO: set adapter node properties?
+  }
+
+  auto result = mStream_->requestStart();
+
+  if (result != oboe::Result::OK) {
+    return ReturnStatus<std::string>::Error(
+        "Failed to start stream: " + std::string(oboe::convertToText(result)));
+  }
+
+  jni::ThreadScope::WithClassLoader(
+      [this]() { nativeAudioRecorder_->start(); });
+
+  state_.store(RecorderState::Recording);
+  return ReturnStatus<std::string>::Success(
+      std::format("file://{}", filePath_));
 }
 
-void AndroidAudioRecorder::start() {
-  if (isRunning_.load()) {
-    return;
+ReturnStatus<std::tuple<std::string, double, double>>
+AndroidAudioRecorder::stop() {
+  Locker callbackLock(callbackMutex_);
+  Locker fileWriterLock(fileWriterMutex_);
+
+  std::string filePath = std::format("file://{}", filePath_);
+  double outputFileSize = 0.0;
+  double outputDuration = 0.0;
+
+  if (!isRecording()) {
+    return ReturnStatus<std::tuple<std::string, double, double>>::Error(
+        "Recorder is not in recording state.");
   }
 
-  if (mStream_) {
-    jni::ThreadScope::WithClassLoader(
-        [this]() { nativeAudioRecorder_->start(); });
-    mStream_->requestStart();
+  if (!mStream_ || !nativeAudioRecorder_) {
+    return ReturnStatus<std::tuple<std::string, double, double>>::Error(
+        "Audio stream is not initialized.");
+  }
+
+  state_.store(RecorderState::Idle);
+  jni::ThreadScope::WithClassLoader([this]() { nativeAudioRecorder_->stop(); });
+  mStream_->requestStop();
+
+  if (usesFileOutput()) {
+    auto fileResult = fileWriter_->closeFile();
+
+    if (!fileResult.isSuccess()) {
+      return ReturnStatus<std::tuple<std::string, double, double>>::Error(
+          "Failed to close file: " + fileResult.getMessage());
+    }
+
+    outputFileSize = std::get<0>(fileResult.getValue());
+    outputDuration = std::get<1>(fileResult.getValue());
   }
 
-  isRunning_.store(true);
+  if (usesCallback()) {
+    callback_->cleanup();
+  }
+
+  filePath_ = "";
+  return ReturnStatus<std::tuple<std::string, double, double>>::Success(
+      {filePath, outputFileSize, outputDuration});
+}
+
+ReturnStatus<std::string> AndroidAudioRecorder::enableFileOutput(
+    std::shared_ptr<AudioFileProperties> properties) {
+  Locker fileWriterLock(fileWriterMutex_);
+
+  if (properties->format == AudioFileProperties::Format::WAV) {
+    fileWriter_ = std::make_shared<MiniAudioFileWriter>(properties);
+  } else {
+    fileWriter_ =
+        std::make_shared<android::ffmpeg::FFmpegAudioFileWriter>(properties);
+  }
+
+  if (!isIdle()) {
+    auto fileResult = fileWriter_->openFile(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+
+    if (!fileResult.isSuccess()) {
+      return ReturnStatus<std::string>::Error(
+          "Failed to open file for writing: " + fileResult.getMessage());
+    }
+
+    filePath_ = fileResult.getValue();
+  }
+
+  fileOutputEnabled_.store(true);
+  return ReturnStatus<std::string>::Success(filePath_);
+}
+
+void AndroidAudioRecorder::disableFileOutput() {
+  Locker fileWriterLock(fileWriterMutex_);
+  fileOutputEnabled_.store(false);
+  fileWriter_ = nullptr;
+}
+
+void AndroidAudioRecorder::pause() {
+  if (!isRecording()) {
+    return;
+  }
+
+  mStream_->pause(0);
+  state_.store(RecorderState::Paused);
 }
 
-void AndroidAudioRecorder::stop() {
-  if (!isRunning_.load()) {
+void AndroidAudioRecorder::resume() {
+  if (!isPaused()) {
     return;
   }
 
-  isRunning_.store(false);
+  mStream_->start(0);
+  state_.store(RecorderState::Recording);
+}
 
-  if (mStream_) {
-    jni::ThreadScope::WithClassLoader(
-        [this]() { nativeAudioRecorder_->stop(); });
-    mStream_->requestStop();
+ReturnStatus<void> AndroidAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId) {
+  Locker callbackLock(callbackMutex_);
+  callback_ = std::make_shared<AndroidRecorderCallback>(
+      audioEventHandlerRegistry_,
+      sampleRate,
+      bufferLength,
+      channelCount,
+      callbackId);
+
+  if (!isIdle()) {
+    callback_->prepare(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
   }
 
-  sendRemainingData();
+  callbackOutputEnabled_.store(true);
+
+  return ReturnStatus<void>::Success();
+}
+
+void AndroidAudioRecorder::clearOnAudioReadyCallback() {
+  Locker callbackLock(callbackMutex_);
+  callbackOutputEnabled_.store(false);
+  callback_ = nullptr;
+}
+
+void AndroidAudioRecorder::setOnErrorCallback(uint64_t callbackId) {
+  // audioEventHandlerRegistry_->registerRecorderErrorCallback(callbackId);
+}
+
+void AndroidAudioRecorder::clearOnErrorCallback() {
+  // audioEventHandlerRegistry_->unregisterRecorderErrorCallback();
 }
 
 DataCallbackResult AndroidAudioRecorder::onAudioReady(
     oboe::AudioStream *oboeStream,
     void *audioData,
     int32_t numFrames) {
-  if (isRunning_.load()) {
-    auto *inputChannel = static_cast<float *>(audioData);
-    writeToBuffers(inputChannel, numFrames);
+  if (isPaused()) {
+    return DataCallbackResult::Continue;
   }
 
-  while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-    auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-    auto *outputChannel = bus->getChannel(0)->getData();
-
-    circularBuffer_->pop_front(outputChannel, bufferLength_);
+  if (usesFileOutput()) {
+    if (auto fileWriterLock = Locker::tryLock(fileWriterMutex_)) {
+      fileWriter_->writeAudioData(audioData, numFrames);
+    }
+  }
 
-    invokeOnAudioReadyCallback(bus, bufferLength_);
+  if (usesCallback()) {
+    if (auto callbackLock = Locker::tryLock(callbackMutex_)) {
+      callback_->receiveAudioData(audioData, numFrames);
+    }
   }
 
   return DataCallbackResult::Continue;
 }
 
+double AndroidAudioRecorder::getCurrentDuration() const {
+  if (usesFileOutput()) {
+    return fileWriter_->getCurrentDuration();
+  }
+
+  return 0.0;
+}
+
+bool AndroidAudioRecorder::isRecording() const {
+  return state_.load() == RecorderState::Recording &&
+      mStream_->getState() == oboe::StreamState::Started;
+}
+
+bool AndroidAudioRecorder::isPaused() const {
+  return state_.load() == RecorderState::Paused;
+}
+
+bool AndroidAudioRecorder::isIdle() const {
+  return state_.load() == RecorderState::Idle;
+}
+
+void AndroidAudioRecorder::cleanup() {
+  state_.store(RecorderState::Idle);
+
+  if (mStream_) {
+    mStream_->close();
+    mStream_.reset();
+  }
+}
+
+void AndroidAudioRecorder::onErrorAfterClose(
+    oboe::AudioStream *stream,
+    oboe::Result error) {
+  if (error == oboe::Result::ErrorDisconnected) {
+    cleanup();
+
+    auto streamResult = openAudioStream();
+
+    if (!streamResult.isSuccess()) {
+      // TODO: call error callback
+      return;
+    }
+
+    mStream_->requestStart();
+    state_.store(RecorderState::Recording);
+  }
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
index e7c9260db..a7445eeb4 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
@@ -1,11 +1,13 @@
 #pragma once
 
 #include <audioapi/core/inputs/AudioRecorder.h>
-
 #include <oboe/Oboe.h>
 #include <functional>
 #include <memory>
-
+#include <string>
+#include <tuple>
+#include <mutex>
+#include <audioapi/utils/ReturnStatus.hpp>
 #include <audioapi/android/core/NativeAudioRecorder.hpp>
 
 namespace audioapi {
@@ -13,28 +15,63 @@ namespace audioapi {
 using namespace oboe;
 
 class AudioBus;
+class CircularAudioArray;
+class AudioFileProperties;
+class AndroidRecorderCallback;
+class AndroidFileWriterBackend;
+class AudioEventHandlerRegistry;
 
-class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorder {
+class AndroidAudioRecorder : public AudioStreamDataCallback,
+                             public AudioStreamErrorCallback, public AudioRecorder {
  public:
-    AndroidAudioRecorder(float sampleRate,
-                         int bufferLength,
-                         const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
-                        );
+  explicit AndroidAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  ~AndroidAudioRecorder() override;
+  void cleanup();
+
+  ReturnStatus<std::string> start() override;
+  ReturnStatus<std::tuple<std::string, double, double>> stop() override;
+
+  ReturnStatus<std::string> enableFileOutput(std::shared_ptr<AudioFileProperties> properties) override;
+  void disableFileOutput() override;
+
+  void pause() override;
+  void resume() override;
+  bool isRecording() const override;
+  bool isPaused() const override;
+  bool isIdle() const override;
 
-    ~AndroidAudioRecorder() override;
+  ReturnStatus<void> setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
 
-    void start() override;
-    void stop() override;
+  void setOnErrorCallback(uint64_t callbackId) override;
+  void clearOnErrorCallback() override;
 
-    DataCallbackResult onAudioReady(
-            AudioStream *oboeStream,
-            void *audioData,
-            int32_t numFrames) override;
+  double getCurrentDuration() const override;
+
+  DataCallbackResult onAudioReady(
+          AudioStream *oboeStream,
+          void *audioData,
+          int32_t numFrames) override;
+  void onErrorAfterClose(AudioStream *oboeStream, Result error) override;
 
  private:
-    std::shared_ptr<AudioStream> mStream_;
+  std::string filePath_;
+  std::shared_ptr<AudioStream> mStream_;
+
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+
+  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
+  std::shared_ptr<AndroidRecorderCallback> callback_;
+
+  int32_t streamSampleRate_;
+  int32_t streamChannelCount_;
+  int32_t streamMaxBufferSizeInFrames_;
+
+  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
 
-    facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
+  ReturnStatus<void> openAudioStream();
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/NativeAudioRecorder.hpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/NativeAudioRecorder.hpp
index f04014e18..786e4699f 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/NativeAudioRecorder.hpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/NativeAudioRecorder.hpp
@@ -22,15 +22,15 @@ class NativeAudioRecorder : public jni::JavaClass<NativeAudioRecorder> {
     return newInstance();
   }
 
-    void start() {
-        static const auto method = javaClassStatic()->getMethod<void()>("start");
-        method(self());
-    }
-
-    void stop() {
-        static const auto method = javaClassStatic()->getMethod<void()>("stop");
-        method(self());
-    }
+  void start() {
+    static const auto method = javaClassStatic()->getMethod<void()>("start");
+    method(self());
+  }
+
+  void stop() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stop");
+    method(self());
+  }
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h
new file mode 100644
index 000000000..89827802d
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <tuple>
+#include <string>
+#include <memory>
+#include <audioapi/utils/ReturnStatus.hpp>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+typedef ReturnStatus<std::string> OpenFileStatus;
+typedef ReturnStatus<std::tuple<double, double>> CloseFileStatus;
+
+class AndroidFileWriterBackend {
+ public:
+  explicit AndroidFileWriterBackend(std::shared_ptr<AudioFileProperties> properties) : properties_(properties) {}
+
+  virtual ~AndroidFileWriterBackend() = default;
+
+  virtual OpenFileStatus openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
+  virtual CloseFileStatus closeFile() = 0;
+
+  virtual bool writeAudioData(void *data, int numFrames) = 0;
+
+  std::string getFilePath() const { return filePath_; }
+
+  double getCurrentDuration() const { return static_cast<double>(framesWritten_.load()) / streamSampleRate_; }
+
+ protected:
+  std::shared_ptr<AudioFileProperties> properties_;
+
+  std::string filePath_{""};
+  std::atomic<size_t> framesWritten_{0};
+
+  int32_t streamSampleRate_{0};
+  int32_t streamChannelCount_{0};
+  int32_t streamMaxBufferSize_{0};
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp
new file mode 100644
index 000000000..d741120df
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.cpp
@@ -0,0 +1,187 @@
+#include <android/log.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/android/core/utils/AndroidRecorderCallback.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+
+#include <memory>
+
+namespace audioapi {
+
+AndroidRecorderCallback::AndroidRecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+    : sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId),
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
+  ringBufferSize_ = std::max((int)bufferLength * 2, 8192);
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto busArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
+    circularBus_[i] = busArray;
+  }
+}
+
+AndroidRecorderCallback::~AndroidRecorderCallback() {
+  for (size_t i = 0; i < circularBus_.size(); ++i) {
+    circularBus_[i].reset();
+  }
+}
+
+void AndroidRecorderCallback::prepare(
+    int32_t streamSampleRate,
+    int32_t streamChannelCount,
+    size_t maxInputBufferLength) {
+  ma_result result;
+
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  maxInputBufferLength_ = maxInputBufferLength;
+
+  ma_data_converter_config converterConfig = ma_data_converter_config_init(
+      ma_format_f32,
+      ma_format_f32,
+      streamChannelCount_,
+      channelCount_,
+      streamSampleRate_,
+      static_cast<int32_t>(sampleRate_));
+
+  converter_ = std::make_unique<ma_data_converter>();
+  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
+
+  if (result != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AndroidRecorderCallback",
+        "Failed to initialize miniaudio data converter");
+    return;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), maxInputBufferLength_, &processingBufferLength_);
+
+  processingBufferLength_ =
+      std::max(processingBufferLength_, (ma_uint64)maxInputBufferLength_);
+
+  deinterleavingArray_ = std::make_shared<AudioArray>(processingBufferLength_);
+  processingBuffer_ = ma_malloc(
+      processingBufferLength_ * channelCount_ *
+          ma_get_bytes_per_sample(ma_format_f32),
+      NULL);
+}
+
+void AndroidRecorderCallback::cleanup() {
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
+  for (size_t i = 0; i < circularBus_.size(); ++i) {
+    circularBus_[i]->zero();
+  }
+}
+
+void AndroidRecorderCallback::receiveAudioData(void *data, int numFrames) {
+  ma_uint64 inputFrameCount = numFrames;
+  ma_uint64 outputFrameCount = 0;
+
+  if ((float)streamSampleRate_ == sampleRate_ &&
+      streamChannelCount_ == channelCount_) {
+    deinterleaveAndWriteAudioData(data, numFrames);
+    emitAudioData();
+    return;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), inputFrameCount, &outputFrameCount);
+
+  ma_data_converter_process_pcm_frames(
+      converter_.get(),
+      data,
+      &inputFrameCount,
+      processingBuffer_,
+      &outputFrameCount);
+
+  deinterleaveAndWriteAudioData(
+      processingBuffer_, static_cast<int>(outputFrameCount));
+  emitAudioData();
+}
+
+void AndroidRecorderCallback::deinterleaveAndWriteAudioData(
+    void *data,
+    int numFrames) {
+  auto *inputData = static_cast<float *>(data);
+
+  for (size_t channel = 0; channel < channelCount_; ++channel) {
+    float *channelData = deinterleavingArray_->getData();
+
+    for (int frame = 0; frame < numFrames; ++frame) {
+      channelData[frame] = inputData[frame * channelCount_ + channel];
+    }
+
+    circularBus_[channel]->push_back(channelData, numFrames);
+  }
+}
+
+void AndroidRecorderCallback::emitAudioData() {
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+    auto bus =
+        std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
+
+    for (int i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, bufferLength_);
+    }
+
+    invokeCallback(bus, (int)bufferLength_);
+  }
+}
+
+void AndroidRecorderCallback::invokeCallback(
+    const std::shared_ptr<AudioBus> &bus,
+    int numFrames) {
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject =
+      std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
+        "audioReady", callbackId_, eventPayload);
+  }
+}
+
+void AndroidRecorderCallback::sendRemainingData() {
+  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
+  auto bus = std::make_shared<AudioBus>(
+      circularBus_[0]->getNumberOfAvailableFrames(),
+      channelCount_,
+      sampleRate_);
+
+  for (int i = 0; i < channelCount_; ++i) {
+    auto *outputChannel = bus->getChannel(i)->getData();
+    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
+  }
+
+  invokeCallback(bus, (int)numberOfFrames);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.h
new file mode 100644
index 000000000..ef5b32aed
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AndroidRecorderCallback.h
@@ -0,0 +1,57 @@
+#pragma once
+
+
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class AudioArray;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class AndroidRecorderCallback {
+ public:
+  AndroidRecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      size_t channelCount,
+      uint64_t callbackId);
+  ~AndroidRecorderCallback();
+
+  void prepare(int32_t streamSampleRate, int32_t streamChannelCount, size_t maxInputBufferLength);
+  void cleanup();
+
+  void receiveAudioData(void *data, int numFrames);
+  void emitAudioData();
+
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+  void sendRemainingData();
+
+ private:
+  int32_t streamSampleRate_;
+  int32_t streamChannelCount_;
+  size_t maxInputBufferLength_;
+
+  float sampleRate_;
+  size_t bufferLength_;
+  size_t channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+
+  ma_uint64 processingBufferLength_{0};
+  void *processingBuffer_{nullptr};
+
+  std::unique_ptr<ma_data_converter> converter_{nullptr};
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+  std::shared_ptr<AudioArray> deinterleavingArray_;
+
+  void deinterleaveAndWriteAudioData(void *data, int numFrames);
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp
index ac0e34a32..b80aa1db4 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/AudioDecoder.cpp
@@ -5,7 +5,6 @@
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 
-#define MINIAUDIO_IMPLEMENTATION
 #include <audioapi/libs/miniaudio/decoders/libopus/miniaudio_libopus.h>
 #include <audioapi/libs/miniaudio/decoders/libvorbis/miniaudio_libvorbis.h>
 #include <audioapi/libs/miniaudio/miniaudio.h>
@@ -99,11 +98,6 @@ std::shared_ptr<AudioBuffer> AudioDecoder::decodeWithFilePath(
       sizeof(customBackends) / sizeof(customBackends[0]);
 
   if (ma_decoder_init_file(path.c_str(), &config, &decoder) != MA_SUCCESS) {
-    __android_log_print(
-        ANDROID_LOG_ERROR,
-        "AudioDecoder",
-        "Failed to initialize decoder for file: %s",
-        path.c_str());
     ma_decoder_uninit(&decoder);
     return nullptr;
   }
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp
new file mode 100644
index 000000000..13f4cef53
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.cpp
@@ -0,0 +1,100 @@
+#include <android/log.h>
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/android/system/NativeFileInfo.hpp>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <chrono>
+#include <filesystem>
+#include <format>
+#include <iostream>
+
+namespace audioapi::android::fileoptions {
+
+bool createDirectoryIfNotExists(const std::string &directoryPath) {
+  std::error_code ec;
+
+  if (!std::filesystem::exists(directoryPath, ec)) {
+    bool created = std::filesystem::create_directories(directoryPath, ec);
+
+    if (ec) {
+      __android_log_print(
+          ANDROID_LOG_ERROR,
+          "FileOptions",
+          "Error creating directory at path: %s, error: %s",
+          directoryPath.c_str(),
+          ec.message().c_str());
+
+      return false;
+    }
+
+    return created;
+  }
+
+  if (ec) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "FileOptions",
+        "Error checking existence of directory at path: %s, error: %s",
+        directoryPath.c_str(),
+        ec.message().c_str());
+
+    return false;
+  }
+
+  return true;
+}
+
+std::string getTimestampString() {
+  auto tNow = std::chrono::system_clock::now();
+  return std::format(
+      "{:%Y%m%d_%H%M%S}", std::chrono::floor<std::chrono::seconds>(tNow));
+}
+
+std::string getDirectory(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->directory) {
+    case AudioFileProperties::FileDirectory::Document:
+      return NativeFileInfo::getFilesDir();
+    case AudioFileProperties::FileDirectory::Cache:
+      return NativeFileInfo::getCacheDir();
+    default:
+      return NativeFileInfo::getCacheDir();
+  }
+}
+
+std::string getFileExtension(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return "wav";
+    case AudioFileProperties::Format::CAF:
+      return "caf";
+    case AudioFileProperties::Format::M4A:
+      return "m4a";
+    case AudioFileProperties::Format::FLAC:
+      return "flac";
+    default:
+      return "m4a";
+  }
+}
+
+std::string getFilePath(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  std::string directory = getDirectory(properties);
+  std::string subDirectory =
+      std::format("{}/{}", directory, properties->subDirectory);
+  std::string fileTimestamp = getTimestampString();
+  std::string extension = getFileExtension(properties);
+
+  if (!createDirectoryIfNotExists(subDirectory)) {
+    return "";
+  }
+
+  return std::format(
+      "{}/{}_{}.{}",
+      subDirectory,
+      properties->fileNamePrefix,
+      fileTimestamp,
+      extension);
+}
+
+} // namespace audioapi::android::fileoptions
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.h
new file mode 100644
index 000000000..1523a5e12
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/FileOptions.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::fileoptions {
+
+bool createDirectoryIfNotExists(const std::string &directoryPath);
+std::string getTimestampString();
+
+std::string getDirectory(const std::shared_ptr<AudioFileProperties> &properties);
+std::string getFileExtension(const std::shared_ptr<AudioFileProperties> &properties);
+std::string getFilePath(const std::shared_ptr<AudioFileProperties> &properties);
+
+} // namespace android::fileoptions
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/MiniaudioImplementation.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/MiniaudioImplementation.cpp
new file mode 100644
index 000000000..890b4be62
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/MiniaudioImplementation.cpp
@@ -0,0 +1,3 @@
+#define MINIAUDIO_IMPLEMENTATION
+#define MA_DEBUG_OUTPUT
+#include <audioapi/libs/miniaudio/miniaudio.h>
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp
new file mode 100644
index 000000000..5d95968d6
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.cpp
@@ -0,0 +1,468 @@
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/audio_fifo.h>
+#include <libavutil/opt.h>
+#include <libswresample/swresample.h>
+}
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h>
+#include <audioapi/android/core/utils/ffmpegBackend/ptrs.hpp>
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
+namespace audioapi::android::ffmpeg {
+
+FFmpegAudioFileWriter::FFmpegAudioFileWriter(
+    std::shared_ptr<AudioFileProperties> properties)
+    : AndroidFileWriterBackend(properties) {}
+
+FFmpegAudioFileWriter::~FFmpegAudioFileWriter() {
+  if (isFileOpen()) {
+    closeFile();
+  }
+}
+
+OpenFileStatus FFmpegAudioFileWriter::openFile(
+    int32_t streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize) {
+  filePath_ = fileoptions::getFilePath(properties_);
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  streamMaxBufferSize_ = streamMaxBufferSize;
+  framesWritten_.store(0);
+  nextPts_ = 0;
+  ReturnStatus<void> status;
+
+  const AVCodec *codec = getCodec(properties_);
+
+  if (!codec) {
+    return OpenFileStatus::Error("Unsupported codec for the given file format");
+  }
+
+  status = initializeFormatContext(codec);
+
+  if (!status.isSuccess()) {
+    return OpenFileStatus::Error(status.getMessage());
+  }
+
+  status = configureAndOpenCodec(codec);
+
+  if (!status.isSuccess()) {
+    return OpenFileStatus::Error(status.getMessage());
+  }
+
+  status = initializeStream();
+
+  if (!status.isSuccess()) {
+    return OpenFileStatus::Error(status.getMessage());
+  }
+
+  status = openIOAndWriteHeader();
+
+  if (!status.isSuccess()) {
+    return OpenFileStatus::Error(status.getMessage());
+  }
+
+  status = initializeResampler(streamSampleRate, streamChannelCount);
+
+  if (!status.isSuccess()) {
+    return OpenFileStatus::Error(status.getMessage());
+  }
+
+  initializeBuffers(streamMaxBufferSize);
+
+  isFileOpen_.store(true);
+  return OpenFileStatus::Success(filePath_);
+}
+
+CloseFileStatus FFmpegAudioFileWriter::closeFile() {
+  int result = 0;
+
+  if (!isFileOpen()) {
+    return CloseFileStatus::Error("File is not open");
+  }
+
+  result = processFifo(true);
+
+  if (result < 0) {
+    auto finalStatus = finalizeOutput();
+
+    return CloseFileStatus::Error(
+        "Failed to flush FIFO to encoder. error code: " +
+        parseErrorCode(result) + ", finalization status: " +
+        (finalStatus.isSuccess() ? "success" : finalStatus.getMessage()));
+  }
+
+  result = avcodec_send_frame(encoderCtx_.get(), nullptr);
+
+  if (result < 0) {
+    return CloseFileStatus::Error("Failed to send EOF to encoder");
+  }
+
+  if (writeEncodedPackets() < 0) {
+    return CloseFileStatus::Error("Failed to drain encoder packets");
+  }
+
+  return finalizeOutput();
+}
+
+bool FFmpegAudioFileWriter::writeAudioData(void *data, int numFrames) {
+  if (!isFileOpen()) {
+    return false;
+  }
+
+  if (!resampleAndPushToFifo(data, numFrames)) {
+    return false;
+  }
+
+  framesWritten_.fetch_add(numFrames);
+
+  if (processFifo(false) < 0) {
+    return false;
+  }
+
+  return true;
+}
+
+bool FFmpegAudioFileWriter::isFileOpen() {
+  return isFileOpen_.load();
+}
+
+bool FFmpegAudioFileWriter::isConverterRequired() {
+  return isConverterRequired_.load();
+}
+
+ReturnStatus<void> FFmpegAudioFileWriter::initializeFormatContext(
+    const AVCodec *codec) {
+  AVFormatContext *rawFormatCtx = nullptr;
+
+  int result = avformat_alloc_output_context2(
+      &rawFormatCtx,
+      nullptr,
+      getMuxerName(properties_).c_str(),
+      filePath_.c_str());
+
+  if (result < 0 || !rawFormatCtx) {
+    return ReturnStatus<void>::Error(
+        "Failed to allocate FFmpeg format context with error: " +
+        parseErrorCode(result));
+  }
+
+  formatCtx_ = av_unique_ptr<AVFormatContext>(rawFormatCtx);
+  return ReturnStatus<void>::Success();
+}
+
+ReturnStatus<void> FFmpegAudioFileWriter::configureAndOpenCodec(
+    const AVCodec *codec) {
+  encoderCtx_ = av_unique_ptr<AVCodecContext>(avcodec_alloc_context3(codec));
+
+  if (!encoderCtx_) {
+    return ReturnStatus<void>::Error("Failed to allocate FFmpeg codec context");
+  }
+
+  av_channel_layout_default(&encoderCtx_->ch_layout, properties_->channelCount);
+  encoderCtx_->sample_rate = properties_->sampleRate;
+  encoderCtx_->sample_fmt = getSampleFormat(properties_);
+
+  if (properties_->bitRate > 0) {
+    encoderCtx_->bit_rate = properties_->bitRate;
+  }
+
+  AVDictionary *codecOptions = nullptr;
+
+  if (properties_->flacCompressionLevel >= 0) {
+    av_dict_set_int(
+        &codecOptions,
+        "compression_level",
+        properties_->flacCompressionLevel,
+        0);
+  }
+
+  int result = avcodec_open2(encoderCtx_.get(), codec, &codecOptions);
+  av_dict_free(&codecOptions);
+
+  if (result < 0) {
+    return ReturnStatus<void>::Error(
+        "Failed to open FFmpeg codec with error: " + parseErrorCode(result));
+  }
+
+  return ReturnStatus<void>::Success();
+}
+
+ReturnStatus<void> FFmpegAudioFileWriter::initializeStream() {
+  stream_ = avformat_new_stream(formatCtx_.get(), nullptr);
+
+  if (!stream_) {
+    return ReturnStatus<void>::Error(
+        "Failed to create new stream in format context");
+  }
+
+  int result =
+      avcodec_parameters_from_context(stream_->codecpar, encoderCtx_.get());
+
+  if (result < 0) {
+    return ReturnStatus<void>::Error(
+        "Failed to copy codec parameters to stream with error: " +
+        parseErrorCode(result));
+  }
+
+  stream_->time_base =
+      AVRational{1, static_cast<int>(encoderCtx_->sample_rate)};
+  return ReturnStatus<void>::Success();
+}
+
+ReturnStatus<void> FFmpegAudioFileWriter::openIOAndWriteHeader() {
+  int result = 0;
+
+  if (!(formatCtx_->oformat->flags & AVFMT_NOFILE)) {
+    result = avio_open(&formatCtx_->pb, filePath_.c_str(), AVIO_FLAG_WRITE);
+
+    if (result < 0) {
+      return ReturnStatus<void>::Error(
+          "Failed to open output file with error: " + parseErrorCode(result));
+    }
+  }
+
+  result = avformat_write_header(formatCtx_.get(), nullptr);
+
+  if (result < 0) {
+    return ReturnStatus<void>::Error(
+        "Failed to write header to file: " + filePath_);
+  }
+
+  return ReturnStatus<void>::Success();
+}
+
+ReturnStatus<void> FFmpegAudioFileWriter::initializeResampler(
+    int32_t inputRate,
+    int32_t inputChannels) {
+  resampleCtx_ = av_unique_ptr<SwrContext>(swr_alloc());
+
+  if (!resampleCtx_) {
+    return ReturnStatus<void>::Error("Failed to allocate resampler context");
+  }
+
+  AVChannelLayout inChannelLayout;
+  av_channel_layout_default(&inChannelLayout, inputChannels);
+
+  av_opt_set_chlayout(resampleCtx_.get(), "in_chlayout", &inChannelLayout, 0);
+  av_opt_set_chlayout(
+      resampleCtx_.get(), "out_chlayout", &encoderCtx_->ch_layout, 0);
+
+  av_opt_set_int(resampleCtx_.get(), "in_sample_rate", inputRate, 0);
+  av_opt_set_int(
+      resampleCtx_.get(), "out_sample_rate", encoderCtx_->sample_rate, 0);
+
+  av_opt_set_sample_fmt(
+      resampleCtx_.get(), "in_sample_fmt", AV_SAMPLE_FMT_FLT, 0);
+  av_opt_set_sample_fmt(
+      resampleCtx_.get(), "out_sample_fmt", encoderCtx_->sample_fmt, 0);
+
+  int result = swr_init(resampleCtx_.get());
+
+  if (result < 0) {
+    return ReturnStatus<void>::Error(
+        "Failed to initialize resampler for file: " + parseErrorCode(result));
+  }
+
+  return ReturnStatus<void>::Success();
+}
+
+void FFmpegAudioFileWriter::initializeBuffers(int32_t maxBufferSize) {
+  frame_ = av_unique_ptr<AVFrame>(av_frame_alloc());
+  packet_ = av_unique_ptr<AVPacket>(av_packet_alloc());
+
+  int contextFrameRatio = 4;
+
+  if (encoderCtx_->frame_size > 0) {
+    contextFrameRatio = static_cast<int>(std::ceil(
+        static_cast<double>(maxBufferSize) /
+        static_cast<double>(encoderCtx_->frame_size)));
+  }
+
+  int calculatedSize =
+      (encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size * contextFrameRatio
+                                   : maxBufferSize * contextFrameRatio);
+
+  int fifoSize = std::max(calculatedSize, 8192);
+
+  audioFifo_ = av_unique_ptr<AVAudioFifo>(av_audio_fifo_alloc(
+      encoderCtx_->sample_fmt, encoderCtx_->ch_layout.nb_channels, fifoSize));
+}
+
+bool FFmpegAudioFileWriter::resampleAndPushToFifo(
+    void *inputData,
+    int inputFrameCount) {
+  int result = 0;
+  int outputLength = av_rescale_rnd(
+      inputFrameCount,
+      encoderCtx_->sample_rate,
+      streamSampleRate_,
+      AV_ROUND_UP);
+
+  result = prepareFrameForEncoding(outputLength);
+
+  if (result < 0) {
+    return false;
+  }
+
+  const uint8_t *inputs[1] = {reinterpret_cast<const uint8_t *>(inputData)};
+
+  int convertedSamples = swr_convert(
+      resampleCtx_.get(), frame_->data, outputLength, inputs, inputFrameCount);
+
+  if (convertedSamples < 0) {
+    av_frame_unref(frame_.get());
+    return false;
+  }
+
+  int written = av_audio_fifo_write(
+      audioFifo_.get(), (void **)frame_->data, convertedSamples);
+
+  if (written < convertedSamples) {
+    return false;
+  }
+
+  return true;
+}
+
+int FFmpegAudioFileWriter::processFifo(bool flush) {
+  int result = 0;
+  int frameSize = encoderCtx_->frame_size > 0 ? encoderCtx_->frame_size : 512;
+
+  while (av_audio_fifo_size(audioFifo_.get()) >= (flush ? 1 : frameSize)) {
+    const int chunkSize =
+        std::min(av_audio_fifo_size(audioFifo_.get()), frameSize);
+
+    if (prepareFrameForEncoding(chunkSize) < 0) {
+      return -1;
+    }
+
+    if (av_audio_fifo_read(
+            audioFifo_.get(), (void **)frame_->data, chunkSize) != chunkSize) {
+      return -1;
+    }
+
+    frame_->pts = nextPts_;
+    nextPts_ += chunkSize;
+
+    result = avcodec_send_frame(encoderCtx_.get(), frame_.get());
+
+    if (result < 0) {
+      return result;
+    }
+
+    result = writeEncodedPackets();
+
+    if (result < 0) {
+      return result;
+    }
+  }
+
+  return 0;
+}
+
+int FFmpegAudioFileWriter::writeEncodedPackets() {
+  int result = 0;
+
+  while (true) {
+    result = avcodec_receive_packet(encoderCtx_.get(), packet_.get());
+
+    if (result == AVERROR(EAGAIN) || result == AVERROR_EOF) {
+      return 0;
+    } else if (result < 0) {
+      return result;
+    }
+
+    av_packet_rescale_ts(
+        packet_.get(), encoderCtx_->time_base, stream_->time_base);
+    packet_->stream_index = stream_->index;
+
+    result = av_interleaved_write_frame(formatCtx_.get(), packet_.get());
+
+    auto now = std::chrono::steady_clock::now();
+    auto elapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(
+                         now - lastFlushTime_)
+                         .count();
+
+    if (formatCtx_->pb && elapsedMs >= flushIntervalMs_) {
+      avio_flush(formatCtx_->pb);
+      lastFlushTime_ = now;
+    }
+
+    if (result < 0) {
+      return result;
+    }
+  }
+}
+
+int FFmpegAudioFileWriter::prepareFrameForEncoding(int samplesToRead) {
+  int result = 0;
+
+  if (frame_->data[0] && frame_->nb_samples == samplesToRead &&
+      av_frame_is_writable(frame_.get())) {
+    return 0;
+  }
+
+  frame_->nb_samples = samplesToRead;
+  frame_->format = encoderCtx_->sample_fmt;
+  frame_->sample_rate = encoderCtx_->sample_rate;
+
+  if (av_channel_layout_compare(&frame_->ch_layout, &encoderCtx_->ch_layout) !=
+      0) {
+    av_channel_layout_uninit(&frame_->ch_layout);
+
+    result =
+        av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
+
+    if (result < 0) {
+      return result;
+    }
+  }
+
+  result = av_frame_make_writable(frame_.get());
+
+  if (result < 0) {
+    av_frame_unref(frame_.get());
+
+    frame_->nb_samples = samplesToRead;
+    frame_->format = encoderCtx_->sample_fmt;
+    frame_->sample_rate = encoderCtx_->sample_rate;
+    av_channel_layout_copy(&frame_->ch_layout, &encoderCtx_->ch_layout);
+
+    result = av_frame_get_buffer(frame_.get(), 0);
+  }
+
+  return result;
+}
+
+CloseFileStatus FFmpegAudioFileWriter::finalizeOutput() {
+  int result = av_write_trailer(formatCtx_.get());
+
+  if (result < 0) {
+    return CloseFileStatus::Error(
+        "Failed to write trailer: " + parseErrorCode(result));
+  }
+
+  double fileSizeInMB = 0;
+
+  if (formatCtx_->pb) {
+    fileSizeInMB = avio_size(formatCtx_->pb) / BYTES_TO_MB;
+    avio_closep(&formatCtx_->pb);
+  }
+
+  double durationInSeconds = getCurrentDuration();
+
+  filePath_ = "";
+  isFileOpen_.store(false);
+
+  return CloseFileStatus::Success({fileSizeInMB, durationInSeconds});
+}
+
+} // namespace audioapi::android::ffmpeg
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h
new file mode 100644
index 000000000..bdbe9cc0b
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/FFmpegFileWriter.h
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+#include <string>
+#include <memory>
+#include <tuple>
+#include <chrono>
+#include <audioapi/utils/ReturnStatus.hpp>
+
+struct AVCodecContext;
+struct AVFormatContext;
+struct AVFrame;
+struct AVPacket;
+struct AVAudioFifo;
+struct SwrContext;
+struct AVStream;
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::ffmpeg {
+
+class FFmpegAudioFileWriter : public AndroidFileWriterBackend {
+ public:
+  explicit FFmpegAudioFileWriter(std::shared_ptr<AudioFileProperties> properties);
+  ~FFmpegAudioFileWriter() override;
+
+  OpenFileStatus openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  CloseFileStatus closeFile() override;
+
+  bool writeAudioData(void *data, int numFrames) override;
+
+ private:
+  std::atomic<bool> isFileOpen_{false};
+  std::atomic<bool> isConverterRequired_{false};
+
+  av_unique_ptr<AVCodecContext> encoderCtx_{nullptr};
+  av_unique_ptr<AVFormatContext> formatCtx_{nullptr};
+  av_unique_ptr<SwrContext> resampleCtx_{nullptr};
+  av_unique_ptr<AVPacket> packet_{nullptr};
+  av_unique_ptr<AVFrame> frame_{nullptr};
+  AVStream* stream_{nullptr};
+  av_unique_ptr<AVAudioFifo> audioFifo_{nullptr};
+  unsigned int nextPts_;
+
+  std::chrono::steady_clock::time_point lastFlushTime_ = std::chrono::steady_clock::now();
+  uint32_t flushIntervalMs_ = 500;
+
+  bool isFileOpen();
+  bool isConverterRequired();
+
+  // Initialization helper methods
+  ReturnStatus<void> initializeFormatContext(const AVCodec* codec);
+  ReturnStatus<void> configureAndOpenCodec(const AVCodec* codec);
+  ReturnStatus<void> initializeStream();
+  ReturnStatus<void> openIOAndWriteHeader();
+  ReturnStatus<void> initializeResampler(int32_t inputRate, int32_t inputChannels);
+  void initializeBuffers(int32_t maxBufferSize);
+
+  // Processing helper methods
+  bool resampleAndPushToFifo(void *data, int numFrames);
+  int processFifo(bool flush);
+  int writeEncodedPackets();
+  int prepareFrameForEncoding(int samplesToRead);
+
+  // Finalization helper methods
+  CloseFileStatus finalizeOutput();
+};
+
+} // namespace android::ffmpeg
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp
new file mode 100644
index 000000000..a805b5c5f
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/ptrs.hpp
@@ -0,0 +1,48 @@
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/audio_fifo.h>
+#include <libswresample/swresample.h>
+}
+
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+
+namespace audioapi::android::ffmpeg {
+
+template<> inline void AvDtor<AVCodecContext>::operator()(AVCodecContext* ctx) const {
+  if (ctx) {
+    avcodec_free_context(&ctx);
+  }
+}
+
+template<> inline void AvDtor<AVFormatContext>::operator()(AVFormatContext* ctx) const {
+  if (ctx) {
+    avformat_free_context(ctx);
+  }
+}
+
+template<> inline void AvDtor<AVFrame>::operator()(AVFrame* frame) const {
+  if (frame) {
+    av_frame_free(&frame);
+  }
+}
+
+template<> inline void AvDtor<AVPacket>::operator()(AVPacket* packet) const {
+  if (packet) {
+    av_packet_free(&packet);
+  }
+}
+
+template<> inline void AvDtor<SwrContext>::operator()(SwrContext* ctx) const {
+  if (ctx) {
+    swr_free(&ctx);
+  }
+}
+
+template<> inline void AvDtor<AVAudioFifo>::operator()(AVAudioFifo* fifo) const {
+  if (fifo) {
+    av_audio_fifo_free(fifo);
+  }
+}
+
+} // namespace audioapi::android::ffmpeg
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp
new file mode 100644
index 000000000..1bf2b06f1
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.cpp
@@ -0,0 +1,89 @@
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+#include <audioapi/android/core/utils/ffmpegBackend/utils.h>
+
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+namespace audioapi::android::ffmpeg {
+
+AVCodecID getPCMCodecID(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return AV_CODEC_ID_PCM_S16LE;
+    case AudioFileProperties::BitDepth::Bit24:
+      return AV_CODEC_ID_PCM_S24LE;
+    case AudioFileProperties::BitDepth::Bit32:
+      return AV_CODEC_ID_PCM_F32LE;
+    default:
+      return AV_CODEC_ID_PCM_F32LE;
+  }
+}
+
+AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+    case AudioFileProperties::Format::CAF:
+      return getPCMCodecID(properties);
+    case AudioFileProperties::Format::M4A:
+      return AV_CODEC_ID_AAC;
+    case AudioFileProperties::Format::FLAC:
+      return AV_CODEC_ID_FLAC;
+    default:
+      return AV_CODEC_ID_AAC;
+  }
+}
+
+AVSampleFormat getSampleFormat(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  if (properties->format == AudioFileProperties::Format::M4A) {
+    return AV_SAMPLE_FMT_FLTP;
+  }
+
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return AV_SAMPLE_FMT_S16;
+    case AudioFileProperties::BitDepth::Bit24:
+      return AV_SAMPLE_FMT_S32;
+    case AudioFileProperties::BitDepth::Bit32:
+      return AV_SAMPLE_FMT_FLT;
+    default:
+      return AV_SAMPLE_FMT_FLT;
+  }
+}
+
+const AVCodec *getCodec(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  return avcodec_find_encoder(getCodecID(properties));
+}
+
+std::string getMuxerName(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return "wav";
+    case AudioFileProperties::Format::CAF:
+      return "caf";
+    case AudioFileProperties::Format::M4A:
+      return "mp4";
+    case AudioFileProperties::Format::FLAC:
+      return "flac";
+    default:
+      return "mp4";
+  }
+}
+
+std::string parseErrorCode(int errorCode) {
+  char errorBuffer[AV_ERROR_MAX_STRING_SIZE];
+
+  if (av_strerror(errorCode, errorBuffer, sizeof(errorBuffer)) < 0) {
+    return "Unknown FFmpeg error: " + std::to_string(errorCode);
+  }
+
+  return std::string(errorBuffer);
+}
+
+} // namespace audioapi::android::ffmpeg
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h
new file mode 100644
index 000000000..239f8c42b
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/ffmpegBackend/utils.h
@@ -0,0 +1,34 @@
+#pragma once
+
+extern "C" {
+#include <libavcodec/avcodec.h>
+}
+
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace android::ffmpeg {
+
+template <typename AVT>
+struct AvDtor {
+  void operator()(AVT* ptr) const;
+};
+
+template<typename AVT>
+using av_unique_ptr = std::unique_ptr<AVT, AvDtor<AVT>>;
+
+AVCodecID getPCMCodecID(const std::shared_ptr<AudioFileProperties> &properties);
+AVCodecID getCodecID(const std::shared_ptr<AudioFileProperties> &properties);
+AVSampleFormat getSampleFormat(const std::shared_ptr<AudioFileProperties> &properties);
+const AVCodec* getCodec(const std::shared_ptr<AudioFileProperties> &properties);
+std::string getMuxerName(const std::shared_ptr<AudioFileProperties> &properties);
+
+std::string parseErrorCode(int errorCode);
+
+} // namespace android::ffmpeg
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp
new file mode 100644
index 000000000..a219a6f73
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.cpp
@@ -0,0 +1,275 @@
+#include <android/log.h>
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/android/core/utils/FileOptions.h>
+#include <audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
+namespace audioapi {
+
+inline ma_encoding_format getFormat(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  return ma_encoding_format_wav;
+}
+
+inline ma_format getDataFormat(
+    const std::shared_ptr<AudioFileProperties> &properties) {
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return ma_format_s16;
+
+    case AudioFileProperties::BitDepth::Bit24:
+      return ma_format_s24;
+
+    case AudioFileProperties::BitDepth::Bit32:
+      return ma_format_f32;
+
+    default:
+      return ma_format_f32;
+  }
+}
+
+MiniAudioFileWriter::MiniAudioFileWriter(
+    std::shared_ptr<AudioFileProperties> properties)
+    : AndroidFileWriterBackend(properties) {}
+
+MiniAudioFileWriter::~MiniAudioFileWriter() {
+  isFileOpen_.store(false);
+  properties_.reset();
+
+  if (encoder_ != nullptr) {
+    ma_encoder_uninit(encoder_.get());
+    encoder_.reset();
+  }
+
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+}
+
+OpenFileStatus MiniAudioFileWriter::openFile(
+    int32_t streamSampleRate,
+    int32_t streamChannelCount,
+    int32_t streamMaxBufferSize) {
+  streamSampleRate_ = streamSampleRate;
+  streamChannelCount_ = streamChannelCount;
+  streamMaxBufferSize_ = streamMaxBufferSize;
+  ma_result result;
+
+  isConverterRequired_.store(
+      (streamSampleRate_ != properties_->sampleRate) ||
+      (streamChannelCount_ != properties_->channelCount) ||
+      (getDataFormat(properties_) != ma_format_f32));
+
+  result = initializeConverterIfNeeded();
+
+  if (result != MA_SUCCESS) {
+    return OpenFileStatus::Error(
+        "Failed to initialize converter" +
+        std::string(ma_result_description(result)));
+  }
+
+  result = initializeEncoder();
+
+  if (result != MA_SUCCESS) {
+    return OpenFileStatus::Error(
+        "Failed to initialize encoder" +
+        std::string(ma_result_description(result)));
+  }
+
+  isFileOpen_.store(true);
+  return OpenFileStatus::Success(filePath_);
+}
+
+CloseFileStatus MiniAudioFileWriter::closeFile() {
+  if (!isFileOpen()) {
+    return CloseFileStatus::Error("File is not open");
+  }
+
+  isFileOpen_.store(false);
+
+  if (encoder_ != nullptr) {
+    ma_encoder_uninit(encoder_.get());
+    encoder_.reset();
+  }
+
+  if (converter_ != nullptr) {
+    ma_data_converter_uninit(converter_.get(), NULL);
+    converter_.reset();
+  }
+
+  if (processingBuffer_ != nullptr) {
+    ma_free(processingBuffer_, NULL);
+    processingBuffer_ = nullptr;
+    processingBufferLength_ = 0;
+  }
+
+  // Retrieve duration and file size
+  std::string filePath = filePath_;
+  double durationInSeconds = 0.0;
+  double fileSizeInMB = 0.0;
+
+  ma_decoder decoder;
+
+  if (ma_decoder_init_file(filePath_.c_str(), NULL, &decoder) == MA_SUCCESS) {
+    ma_uint64 frameCount = 0;
+
+    if (ma_decoder_get_length_in_pcm_frames(&decoder, &frameCount) ==
+        MA_SUCCESS) {
+      durationInSeconds =
+          static_cast<double>(frameCount) / decoder.outputSampleRate;
+    }
+
+    ma_decoder_uninit(&decoder);
+  }
+
+  FILE *file = fopen(filePath_.c_str(), "rb");
+
+  if (file != nullptr) {
+    fseek(file, 0, SEEK_END);
+    long fileSizeInBytes = ftell(file);
+    fclose(file);
+    fileSizeInMB = static_cast<double>(fileSizeInBytes) / BYTES_TO_MB;
+  }
+
+  filePath_ = "";
+  return CloseFileStatus::Success({fileSizeInMB, durationInSeconds});
+}
+
+bool MiniAudioFileWriter::writeAudioData(void *data, int numFrames) {
+  ma_uint64 framesWritten = 0;
+  ma_result result;
+
+  if (!isFileOpen()) {
+    return false;
+  }
+
+  if (!isConverterRequired()) {
+    result = ma_encoder_write_pcm_frames(
+        encoder_.get(), data, numFrames, &framesWritten);
+
+    __android_log_print(
+        ANDROID_LOG_DEBUG,
+        "MiniAudioFileWriter",
+        "Writing %llu frames without conversion to file: %s",
+        framesWritten,
+        filePath_.c_str());
+
+    if (result != MA_SUCCESS) {
+      __android_log_print(
+          ANDROID_LOG_ERROR,
+          "MiniAudioFileWriter",
+          "Failed to write audio data to file: %s",
+          filePath_.c_str());
+    }
+
+    framesWritten_.fetch_add(numFrames);
+    return result == MA_SUCCESS;
+  }
+
+  ma_uint64 convertedFrameCount = convertBuffer(data, numFrames);
+
+  result = ma_encoder_write_pcm_frames(
+      encoder_.get(), processingBuffer_, convertedFrameCount, &framesWritten);
+
+  if (result != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "MiniAudioFileWriter",
+        "Failed to write converted audio data to file: %s",
+        filePath_.c_str());
+  }
+
+  framesWritten_.fetch_add(numFrames);
+  return result == MA_SUCCESS;
+}
+
+ma_uint64 MiniAudioFileWriter::convertBuffer(void *data, int numFrames) {
+  ma_uint64 inputFrameCount = numFrames;
+  ma_uint64 outputFrameCount = 0;
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), inputFrameCount, &outputFrameCount);
+
+  ma_data_converter_process_pcm_frames(
+      converter_.get(),
+      data,
+      &inputFrameCount,
+      processingBuffer_,
+      &outputFrameCount);
+
+  return outputFrameCount;
+}
+
+ma_result MiniAudioFileWriter::initializeConverterIfNeeded() {
+  if (!isConverterRequired_) {
+    return MA_SUCCESS;
+  }
+
+  ma_result result;
+  ma_format dataFormat = getDataFormat(properties_);
+
+  ma_data_converter_config converterConfig = ma_data_converter_config_init(
+      ma_format_f32,
+      dataFormat,
+      streamChannelCount_,
+      properties_->channelCount,
+      streamSampleRate_,
+      properties_->sampleRate);
+
+  converter_ = std::make_unique<ma_data_converter>();
+  result = ma_data_converter_init(&converterConfig, NULL, converter_.get());
+
+  if (result != MA_SUCCESS) {
+    return result;
+  }
+
+  ma_data_converter_get_expected_output_frame_count(
+      converter_.get(), streamMaxBufferSize_, &processingBufferLength_);
+
+  processingBuffer_ = ma_malloc(
+      processingBufferLength_ * properties_->channelCount *
+          ma_get_bytes_per_sample(dataFormat),
+      NULL);
+
+  return MA_SUCCESS;
+}
+
+ma_result MiniAudioFileWriter::initializeEncoder() {
+  ma_result result;
+  filePath_ = android::fileoptions::getFilePath(properties_);
+
+  ma_encoder_config config = ma_encoder_config_init(
+      getFormat(properties_),
+      getDataFormat(properties_),
+      properties_->channelCount,
+      properties_->sampleRate);
+
+  encoder_ = std::make_unique<ma_encoder>();
+  result = ma_encoder_init_file(filePath_.c_str(), &config, encoder_.get());
+
+  if (result != MA_SUCCESS) {
+    return result;
+  }
+
+  return MA_SUCCESS;
+}
+
+bool MiniAudioFileWriter::isFileOpen() {
+  return isFileOpen_.load();
+}
+
+bool MiniAudioFileWriter::isConverterRequired() {
+  return isConverterRequired_.load();
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h
new file mode 100644
index 000000000..a1f679ae5
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/utils/miniaudioBackend/MiniAudioFileWriter.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
+#include <audioapi/libs/miniaudio/miniaudio.h>
+
+#include <string>
+#include <memory>
+#include <tuple>
+
+namespace audioapi {
+
+class MiniAudioFileWriter : public AndroidFileWriterBackend {
+ public:
+  explicit MiniAudioFileWriter(std::shared_ptr<AudioFileProperties> properties);
+  ~MiniAudioFileWriter() override;
+
+  OpenFileStatus openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) override;
+  CloseFileStatus closeFile() override;
+
+  bool writeAudioData(void *data, int numFrames) override;
+
+ private:
+  std::atomic<bool> isFileOpen_{false};
+  std::atomic<bool> isConverterRequired_{false};
+
+  std::unique_ptr<ma_encoder> encoder_{nullptr};
+  std::unique_ptr<ma_data_converter> converter_{nullptr};
+  void *processingBuffer_{nullptr};
+  ma_uint64 processingBufferLength_{0};
+
+  ma_result initializeConverterIfNeeded();
+  ma_result initializeEncoder();
+  ma_uint64 convertBuffer(void *data, int numFrames);
+
+  bool isFileOpen();
+  bool isConverterRequired();
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/system/NativeFileInfo.hpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/system/NativeFileInfo.hpp
new file mode 100644
index 000000000..166b40bbc
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/system/NativeFileInfo.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/jni/CxxModuleWrapper.h>
+#include <react/jni/JMessageQueueThread.h>
+#include <memory>
+#include <utility>
+#include <unordered_map>
+
+namespace audioapi {
+
+using namespace facebook;
+using namespace react;
+
+class NativeFileInfo : public jni::JavaClass<NativeFileInfo> {
+ public:
+  static auto constexpr kJavaDescriptor =
+            "Lcom/swmansion/audioapi/system/NativeFileInfo;";
+
+  static std::string getFilesDir() {
+    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getFilesDir");
+    return method(javaClassStatic())->toStdString();
+  }
+
+  static std::string getCacheDir() {
+    static const auto method = javaClassStatic()->getStaticMethod<jni::JString()>("getCacheDir");
+    return method(javaClassStatic())->toStdString();
+  }
+};
+
+}
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt
index 4ffa63356..30ca935e9 100644
--- a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt
@@ -10,6 +10,7 @@ import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.swmansion.audioapi.system.MediaSessionManager
+import com.swmansion.audioapi.system.NativeFileInfo
 import com.swmansion.audioapi.system.PermissionRequestListener
 import java.lang.ref.WeakReference
 
@@ -63,6 +64,7 @@ class AudioAPIModule(
 
   override fun install(): Boolean {
     MediaSessionManager.initialize(WeakReference(this), reactContext)
+    NativeFileInfo.initialize(reactContext)
     injectJSIBindings()
 
     return true
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioFocusListener.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioFocusListener.kt
index e2cdd9727..74490b786 100644
--- a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioFocusListener.kt
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/AudioFocusListener.kt
@@ -13,14 +13,12 @@ class AudioFocusListener(
   private val audioAPIModule: WeakReference<AudioAPIModule>,
   private val lockScreenManager: WeakReference<LockScreenManager>,
 ) : AudioManager.OnAudioFocusChangeListener {
-  private var playOnAudioFocus: Boolean = false
   private var focusRequest: AudioFocusRequest? = null
 
   override fun onAudioFocusChange(focusChange: Int) {
     Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
     when (focusChange) {
       AudioManager.AUDIOFOCUS_LOSS -> {
-        playOnAudioFocus = false
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
@@ -28,33 +26,23 @@ class AudioFocusListener(
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
+
       AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-        playOnAudioFocus = lockScreenManager.get()?.isPlaying == true
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("shouldResume", playOnAudioFocus)
+            put("shouldResume", false)
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
-      AudioManager.AUDIOFOCUS_GAIN -> {
-        if (playOnAudioFocus) {
-          val body =
-            HashMap<String, Any>().apply {
-              put("type", "ended")
-              put("shouldResume", true)
-            }
-          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
-        } else {
-          val body =
-            HashMap<String, Any>().apply {
-              put("type", "ended")
-              put("shouldResume", false)
-            }
-          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
-        }
 
-        playOnAudioFocus = false
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        val body =
+          HashMap<String, Any>().apply {
+            put("type", "ended")
+            put("shouldResume", true)
+          }
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
     }
   }
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/NativeFileInfo.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/NativeFileInfo.kt
new file mode 100644
index 000000000..a1c7c6afb
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/NativeFileInfo.kt
@@ -0,0 +1,18 @@
+package com.swmansion.audioapi.system
+
+import com.facebook.react.bridge.ReactApplicationContext
+import java.lang.ref.WeakReference
+
+object NativeFileInfo {
+  private lateinit var reactContext: WeakReference<ReactApplicationContext>
+
+  fun initialize(reactContext: WeakReference<ReactApplicationContext>) {
+    this.reactContext = reactContext
+  }
+
+  @JvmStatic
+  fun getFilesDir(): String = reactContext.get()?.filesDir?.absolutePath ?: ""
+
+  @JvmStatic
+  fun getCacheDir(): String = reactContext.get()?.cacheDir?.absolutePath ?: ""
+}
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavcodec.so b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavcodec.so
new file mode 100755
index 000000000..96442b899
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavcodec.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavformat.so b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavformat.so
new file mode 100755
index 000000000..60ac543b1
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavformat.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavutil.so b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavutil.so
new file mode 100755
index 000000000..c9060e778
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libavutil.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libswresample.so b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libswresample.so
new file mode 100755
index 000000000..1c713b2fe
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/arm64-v8a/libswresample.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavcodec.so b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavcodec.so
new file mode 100755
index 000000000..77eac12c8
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavcodec.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavformat.so b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavformat.so
new file mode 100755
index 000000000..4586d12f1
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavformat.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavutil.so b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavutil.so
new file mode 100755
index 000000000..e2254b4cc
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libavutil.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libswresample.so b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libswresample.so
new file mode 100755
index 000000000..c3e40d271
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/armeabi-v7a/libswresample.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavcodec.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavcodec.so
new file mode 100755
index 000000000..6133b0449
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavcodec.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavformat.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavformat.so
new file mode 100755
index 000000000..251e8a897
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavformat.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavutil.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavutil.so
new file mode 100755
index 000000000..6c2811b12
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libavutil.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86/libswresample.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libswresample.so
new file mode 100755
index 000000000..4447ff62c
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86/libswresample.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavcodec.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavcodec.so
new file mode 100755
index 000000000..a5d36ac1d
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavcodec.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavformat.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavformat.so
new file mode 100755
index 000000000..61391b904
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavformat.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavutil.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavutil.so
new file mode 100755
index 000000000..115f47a7d
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libavutil.so differ
diff --git a/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libswresample.so b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libswresample.so
new file mode 100755
index 000000000..225e5e4ac
Binary files /dev/null and b/packages/react-native-audio-api/android/src/main/jniLibs/x86_64/libswresample.so differ
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/AudioAPIModuleInstaller.h b/packages/react-native-audio-api/common/cpp/audioapi/AudioAPIModuleInstaller.h
index 73778ce14..fadebd8d2 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/AudioAPIModuleInstaller.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/AudioAPIModuleInstaller.h
@@ -16,6 +16,7 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace audioapi {
@@ -180,17 +181,8 @@ class AudioAPIModuleInstaller {
             const jsi::Value &thisValue,
             const jsi::Value *args,
             size_t count) -> jsi::Value {
-          auto options = args[0].getObject(runtime);
-
-          auto sampleRate = static_cast<float>(
-              options.getProperty(runtime, "sampleRate").getNumber());
-          auto bufferLength = static_cast<int>(
-              options.getProperty(runtime, "bufferLengthInSamples")
-                  .getNumber());
-
           auto audioRecorderHostObject =
-              std::make_shared<AudioRecorderHostObject>(
-                  audioEventHandlerRegistry, sampleRate, bufferLength);
+              std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry);
 
           return jsi::Object::createFromHostObject(
               runtime, audioRecorderHostObject);
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
index 5f4bbca87..78111f7ae 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp
@@ -5,6 +5,7 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #ifdef ANDROID
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #else
@@ -14,35 +15,144 @@
 namespace audioapi {
 
 AudioRecorderHostObject::AudioRecorderHostObject(
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-    float sampleRate,
-    int bufferLength) {
+    const std::shared_ptr<AudioEventHandlerRegistry>
+        &audioEventHandlerRegistry) {
 #ifdef ANDROID
-  audioRecorder_ = std::make_shared<AndroidAudioRecorder>(
-      sampleRate, bufferLength, audioEventHandlerRegistry);
+  audioRecorder_ =
+      std::make_shared<AndroidAudioRecorder>(audioEventHandlerRegistry);
 #else
-  audioRecorder_ = std::make_shared<IOSAudioRecorder>(
-      sampleRate, bufferLength, audioEventHandlerRegistry);
+  audioRecorder_ =
+      std::make_shared<IOSAudioRecorder>(audioEventHandlerRegistry);
 #endif
 
-  addSetters(JSI_EXPORT_PROPERTY_SETTER(AudioRecorderHostObject, onAudioReady));
-
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, isRecording),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, enableFileOutput),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disableFileOutput),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, pause),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, resume),
       JSI_EXPORT_FUNCTION(AudioRecorderHostObject, connect),
-      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect));
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, disconnect),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, setOnAudioReady),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, clearOnAudioReady),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, setOnError),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, clearOnError),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, getCurrentDuration));
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
+  auto result = audioRecorder_->start();
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(
+          runtime, result.isSuccess() ? "success" : "error"));
+
+  if (result.isSuccess()) {
+    jsResult.setProperty(
+        runtime,
+        "path",
+        jsi::String::createFromUtf8(runtime, result.getValue()));
+  } else {
+    jsResult.setProperty(
+        runtime,
+        "message",
+        jsi::String::createFromUtf8(runtime, result.getMessage()));
+  }
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
+  auto result = audioRecorder_->stop();
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(
+          runtime, result.isSuccess() ? "success" : "error"));
+
+  if (result.isSuccess()) {
+    auto info = result.getValue();
+
+    jsResult.setProperty(
+        runtime,
+        "path",
+        jsi::String::createFromUtf8(runtime, std::get<0>(info)));
+    jsResult.setProperty(runtime, "size", std::get<1>(info));
+    jsResult.setProperty(runtime, "duration", std::get<2>(info));
+  } else {
+    jsResult.setProperty(
+        runtime,
+        "message",
+        jsi::String::createFromUtf8(runtime, result.getMessage()));
+  }
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, isRecording) {
+  return jsi::Value(audioRecorder_->isRecording());
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, isPaused) {
+  return jsi::Value(audioRecorder_->isPaused());
 }
 
-JSI_PROPERTY_SETTER_IMPL(AudioRecorderHostObject, onAudioReady) {
-  audioRecorder_->setOnAudioReadyCallbackId(
-      std::stoull(value.getString(runtime).utf8(runtime)));
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, enableFileOutput) {
+  auto fileProperties =
+      AudioFileProperties::CreateFromJSIValue(runtime, args[0]);
+
+  auto result = audioRecorder_->enableFileOutput(fileProperties);
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(
+          runtime, result.isSuccess() ? "success" : "error"));
+
+  if (result.isSuccess()) {
+    jsResult.setProperty(
+        runtime,
+        "path",
+        jsi::String::createFromUtf8(runtime, result.getValue()));
+  } else {
+    jsResult.setProperty(
+        runtime,
+        "message",
+        jsi::String::createFromUtf8(runtime, result.getMessage()));
+  }
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, disableFileOutput) {
+  audioRecorder_->disableFileOutput();
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, pause) {
+  audioRecorder_->pause();
+
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, resume) {
+  audioRecorder_->resume();
+  return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
   auto adapterNodeHostObject =
       args[0].getObject(runtime).getHostObject<RecorderAdapterNodeHostObject>(
           runtime);
+
   audioRecorder_->connect(
       std::static_pointer_cast<RecorderAdapterNode>(
           adapterNodeHostObject->node_));
@@ -51,19 +161,60 @@ JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, connect) {
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, disconnect) {
   audioRecorder_->disconnect();
+
   return jsi::Value::undefined();
 }
 
-JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
-  audioRecorder_->start();
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, setOnAudioReady) {
+  auto options = args[0].getObject(runtime);
+
+  auto sampleRate = static_cast<float>(
+      options.getProperty(runtime, "sampleRate").getNumber());
+  auto bufferLength = static_cast<size_t>(
+      options.getProperty(runtime, "bufferLength").getNumber());
+  auto channelCount = static_cast<size_t>(
+      options.getProperty(runtime, "channelCount").getNumber());
+  uint64_t callbackId = std::stoull(options.getProperty(runtime, "callbackId")
+                                        .getString(runtime)
+                                        .utf8(runtime));
 
+  auto result = audioRecorder_->setOnAudioReadyCallback(
+      sampleRate, bufferLength, channelCount, callbackId);
+  auto jsResult = jsi::Object(runtime);
+
+  jsResult.setProperty(
+      runtime,
+      "status",
+      jsi::String::createFromUtf8(
+          runtime, result.isSuccess() ? "success" : "error"));
+
+  return jsResult;
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, clearOnAudioReady) {
+  audioRecorder_->clearOnAudioReadyCallback();
   return jsi::Value::undefined();
 }
 
-JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, stop) {
-  audioRecorder_->stop();
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, setOnError) {
+  auto options = args[0].getObject(runtime);
+
+  uint64_t callbackId = std::stoull(options.getProperty(runtime, "callbackId")
+                                        .getString(runtime)
+                                        .utf8(runtime));
 
+  audioRecorder_->setOnErrorCallback(callbackId);
   return jsi::Value::undefined();
 }
 
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, clearOnError) {
+  audioRecorder_->clearOnErrorCallback();
+  return jsi::Value::undefined();
+}
+
+JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, getCurrentDuration) {
+  double duration = audioRecorder_->getCurrentDuration();
+  return jsi::Value(duration);
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h
index 49ac75d63..2ada6fd9c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.h
@@ -6,6 +6,7 @@
 #include <utility>
 #include <vector>
 #include <cstdio>
+#include <string>
 
 namespace audioapi {
 using namespace facebook;
@@ -16,18 +17,32 @@ class AudioEventHandlerRegistry;
 class AudioRecorderHostObject : public JsiHostObject {
  public:
   explicit AudioRecorderHostObject(
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
-      float sampleRate,
-      int bufferLength);
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
 
-  JSI_PROPERTY_SETTER_DECL(onAudioReady);
+  JSI_HOST_FUNCTION_DECL(start);
+  JSI_HOST_FUNCTION_DECL(stop);
+  JSI_HOST_FUNCTION_DECL(isRecording);
+  JSI_HOST_FUNCTION_DECL(isPaused);
+
+  JSI_HOST_FUNCTION_DECL(enableFileOutput);
+  JSI_HOST_FUNCTION_DECL(disableFileOutput);
+
+  JSI_HOST_FUNCTION_DECL(pause);
+  JSI_HOST_FUNCTION_DECL(resume);
 
   JSI_HOST_FUNCTION_DECL(connect);
   JSI_HOST_FUNCTION_DECL(disconnect);
-  JSI_HOST_FUNCTION_DECL(start);
-  JSI_HOST_FUNCTION_DECL(stop);
+
+  JSI_HOST_FUNCTION_DECL(setOnAudioReady);
+  JSI_HOST_FUNCTION_DECL(clearOnAudioReady);
+
+  JSI_HOST_FUNCTION_DECL(setOnError);
+  JSI_HOST_FUNCTION_DECL(clearOnError);
+
+  JSI_HOST_FUNCTION_DECL(getCurrentDuration);
 
  private:
   std::shared_ptr<AudioRecorder> audioRecorder_;
 };
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.cpp
deleted file mode 100644
index c5e4186d3..000000000
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
-#include <audioapi/core/inputs/AudioRecorder.h>
-#include <audioapi/core/sources/AudioBuffer.h>
-#include <audioapi/core/sources/RecorderAdapterNode.h>
-#include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/utils/AudioBus.h>
-#include <audioapi/utils/CircularAudioArray.h>
-#include <audioapi/utils/CircularOverflowableAudioArray.h>
-
-namespace audioapi {
-
-AudioRecorder::AudioRecorder(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : sampleRate_(sampleRate),
-      bufferLength_(bufferLength),
-      audioEventHandlerRegistry_(audioEventHandlerRegistry) {
-  constexpr int minRingBufferSize = 8192;
-  ringBufferSize_ = std::max(2 * bufferLength, minRingBufferSize);
-  circularBuffer_ = std::make_shared<CircularAudioArray>(ringBufferSize_);
-  isRunning_.store(false);
-}
-
-void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
-  onAudioReadyCallbackId_ = callbackId;
-}
-
-void AudioRecorder::invokeOnAudioReadyCallback(
-    const std::shared_ptr<AudioBus> &bus,
-    int numFrames) {
-  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
-  auto audioBufferHostObject =
-      std::make_shared<AudioBufferHostObject>(audioBuffer);
-
-  std::unordered_map<std::string, EventValue> body = {};
-  body.insert({"buffer", audioBufferHostObject});
-  body.insert({"numFrames", numFrames});
-
-  if (audioEventHandlerRegistry_ != nullptr) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "audioReady", onAudioReadyCallbackId_, body);
-  }
-}
-
-void AudioRecorder::sendRemainingData() {
-  auto bus = std::make_shared<AudioBus>(
-      circularBuffer_->getNumberOfAvailableFrames(), 1, sampleRate_);
-  auto *outputChannel = bus->getChannel(0)->getData();
-  auto availableFrames =
-      static_cast<int>(circularBuffer_->getNumberOfAvailableFrames());
-
-  circularBuffer_->pop_front(
-      outputChannel, circularBuffer_->getNumberOfAvailableFrames());
-
-  invokeOnAudioReadyCallback(bus, availableFrames);
-}
-
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  node->init(ringBufferSize_);
-  adapterNodeLock_.lock();
-  adapterNode_ = node;
-  adapterNodeLock_.unlock();
-}
-
-void AudioRecorder::disconnect() {
-  adapterNodeLock_.lock();
-  adapterNode_ = nullptr;
-  adapterNodeLock_.unlock();
-}
-
-void AudioRecorder::writeToBuffers(const float *data, int numFrames) {
-  if (adapterNodeLock_.try_lock()) {
-    if (adapterNode_ != nullptr) {
-      adapterNode_->buff_->write(data, numFrames);
-    }
-    adapterNodeLock_.unlock();
-  }
-  circularBuffer_->push_back(data, numFrames);
-}
-
-} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
index 471d06fc7..22bc4cbc5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/inputs/AudioRecorder.h
@@ -3,61 +3,75 @@
 #include <memory>
 #include <atomic>
 #include <mutex>
+#include <string>
+#include <tuple>
+#include <audioapi/utils/ReturnStatus.hpp>
 
 namespace audioapi {
 
-class RecorderAdapterNode;
 class AudioBus;
 class CircularAudioArray;
-class CircularOverflowableAudioArray;
+class RecorderAdapterNode;
+class AudioFileProperties;
 class AudioEventHandlerRegistry;
 
 class AudioRecorder {
  public:
-  explicit AudioRecorder(
+  enum class RecorderState { Idle = 0, Recording, Paused };
+  explicit AudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry):
+      audioEventHandlerRegistry_(audioEventHandlerRegistry) {}
+  virtual ~AudioRecorder() = default;
+
+  virtual ReturnStatus<std::string> start() = 0;
+  virtual ReturnStatus<std::tuple<std::string, double, double>> stop() = 0;
+
+  virtual ReturnStatus<std::string> enableFileOutput(std::shared_ptr<AudioFileProperties> properties) = 0;
+  virtual void disableFileOutput() = 0;
+
+  virtual void pause() = 0;
+  virtual void resume() = 0;
+
+  void connect(const std::shared_ptr<RecorderAdapterNode> &node) {}
+  void disconnect() {}
+
+  virtual ReturnStatus<void> setOnAudioReadyCallback(
     float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
-  );
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId) = 0;
+  virtual void clearOnAudioReadyCallback() = 0;
 
-  virtual ~AudioRecorder() = default;
+  virtual void setOnErrorCallback(uint64_t callbackId) = 0;
+  virtual void clearOnErrorCallback() = 0;
 
-  void setOnAudioReadyCallbackId(uint64_t callbackId);
-  void invokeOnAudioReadyCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
-  void sendRemainingData();
+  virtual double getCurrentDuration() const = 0;
 
-  /// @brief
-  /// # Connects the recorder to the adapter node.
-  ///
-  /// The adapter node will be used to read audio data from the recorder.
-  /// @note Few frames of audio might not yet be written to the buffer when connecting.
-  void connect(const std::shared_ptr<RecorderAdapterNode> &node);
+  bool usesCallback() const {
+    return callbackOutputEnabled_.load();
+  }
 
-  /// @brief
-  /// # Disconnects the recorder from the adapter node.
-  ///
-  /// The adapter node will no longer be used to read audio data from the recorder.
-  /// @note Last few frames of audio might be written to the buffer after disconnecting.
-  void disconnect();
+  bool usesFileOutput() const {
+    return fileOutputEnabled_.load();
+  }
 
-  virtual void start() = 0;
-  virtual void stop() = 0;
+  bool isConnected() const {
+    return isConnected_.load();
+  }
 
- protected:
-  float sampleRate_;
-  int bufferLength_;
-  size_t ringBufferSize_;
+  virtual bool isRecording() const = 0;
+  virtual bool isPaused() const = 0;
+  virtual bool isIdle() const = 0;
 
-  std::atomic<bool> isRunning_;
-  std::shared_ptr<CircularAudioArray> circularBuffer_;
+ protected:
+  std::atomic<RecorderState> state_{ RecorderState::Idle };
+  std::atomic<bool> fileOutputEnabled_{false};
+  std::atomic<bool> callbackOutputEnabled_{false};
+  std::atomic<bool> isConnected_{false};
 
   mutable std::mutex adapterNodeLock_;
   std::shared_ptr<RecorderAdapterNode> adapterNode_ = nullptr;
 
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
-  uint64_t onAudioReadyCallbackId_ = 0;
-
-  void writeToBuffers(const float *data, int numFrames);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/avcodec.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/avcodec.h
index df000f64f..41055c503 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/avcodec.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/avcodec.h
@@ -436,7 +436,7 @@ typedef struct AVCodecContext {
     const AVClass *av_class;
     int log_level_offset;
 
-    enum AVMediaTypeFFmpeg codec_type; /* see AVMEDIA_TYPE_xxx */
+    enum AVMediaTypeFFMPEG codec_type; /* see AVMEDIA_TYPE_xxx */
     const struct AVCodec  *codec;
     enum AVCodecID     codec_id; /* see AV_CODEC_ID_xxx */
 
@@ -1946,7 +1946,7 @@ typedef struct AVHWAccel {
      *
      * See AVMEDIA_TYPE_xxx
      */
-    enum AVMediaTypeFFmpeg type;
+    enum AVMediaTypeFFMPEG type;
 
     /**
      * Codec implemented by the hardware accelerator.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec.h
index 849215c60..ffb154ff7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec.h
@@ -182,7 +182,7 @@ typedef struct AVCodec {
      * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
      */
     const char *long_name;
-    enum AVMediaTypeFFmpeg type;
+    enum AVMediaTypeFFMPEG type;
     enum AVCodecID id;
     /**
      * Codec capabilities.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_desc.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_desc.h
index 5e158f352..087a7181a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_desc.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_desc.h
@@ -37,7 +37,7 @@
  */
 typedef struct AVCodecDescriptor {
     enum AVCodecID     id;
-    enum AVMediaTypeFFmpeg type;
+    enum AVMediaTypeFFMPEG type;
     /**
      * Name of the codec described by this descriptor. It is non-empty and
      * unique for each codec descriptor. It should contain alphanumeric
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_id.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_id.h
index d52dd6fba..2ad0dc477 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_id.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_id.h
@@ -629,7 +629,7 @@ enum AVCodecID {
 /**
  * Get the type of the given codec.
  */
-enum AVMediaTypeFFmpeg avcodec_get_type(enum AVCodecID codec_id);
+enum AVMediaTypeFFMPEG avcodec_get_type(enum AVCodecID codec_id);
 
 /**
  * Get the name of a codec.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_par.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_par.h
index 53a43aa44..aef6e9d8b 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_par.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavcodec/codec_par.h
@@ -48,7 +48,7 @@ typedef struct AVCodecParameters {
     /**
      * General type of the encoded data.
      */
-    enum AVMediaTypeFFmpeg codec_type;
+    enum AVMediaTypeFFMPEG codec_type;
     /**
      * Specific type of the encoded data (the codec used).
      */
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavformat/avformat.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavformat/avformat.h
index 17b7b3cbb..6a8b2c943 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavformat/avformat.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavformat/avformat.h
@@ -2253,7 +2253,7 @@ void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int i
  *        NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec.
  */
 int av_find_best_stream(AVFormatContext *ic,
-                        enum AVMediaTypeFFmpeg type,
+                        enum AVMediaTypeFFMPEG type,
                         int wanted_stream_nb,
                         int related_stream,
                         const struct AVCodec **decoder_ret,
@@ -2593,7 +2593,7 @@ const AVOutputFormat *av_guess_format(const char *short_name,
  */
 enum AVCodecID av_guess_codec(const AVOutputFormat *fmt, const char *short_name,
                               const char *filename, const char *mime_type,
-                              enum AVMediaTypeFFmpeg type);
+                              enum AVMediaTypeFFMPEG type);
 
 /**
  * Get timing information for the data currently output.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavutil/avutil.h b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavutil/avutil.h
index ce5e02a12..7fe255a0d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavutil/avutil.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/external/ffmpeg_include/libavutil/avutil.h
@@ -195,7 +195,7 @@ const char *avutil_license(void);
  * @brief Media Type
  */
 
-enum AVMediaTypeFFmpeg {
+enum AVMediaTypeFFMPEG {
     AVMEDIA_TYPE_UNKNOWN = -1,  ///< Usually treated as AVMEDIA_TYPE_DATA
     AVMEDIA_TYPE_VIDEO,
     AVMEDIA_TYPE_AUDIO,
@@ -209,7 +209,7 @@ enum AVMediaTypeFFmpeg {
  * Return a string describing the media_type enum, NULL if media_type
  * is unknown.
  */
-const char *av_get_media_type_string(enum AVMediaTypeFFmpeg media_type);
+const char *av_get_media_type_string(enum AVMediaTypeFFMPEG media_type);
 
 /**
  * @defgroup lavu_const Constants
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.cpp b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.cpp
new file mode 100644
index 000000000..ed5890bbd
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.cpp
@@ -0,0 +1,90 @@
+#include <audioapi/utils/AudioFileProperties.h>
+
+#include <audioapi/jsi/JsiHostObject.h>
+#include <jsi/jsi.h>
+#include <algorithm>
+
+namespace audioapi {
+
+AudioFileProperties::AudioFileProperties(
+    FileDirectory directory,
+    const std::string &subDirectory,
+    const std::string &fileNamePrefix,
+    size_t channelCount,
+    size_t batchDurationSeconds,
+    Format format,
+    size_t sampleRate,
+    size_t bitRate,
+    BitDepth bitDepth,
+    int flacCompressionLevel,
+    IOSAudioQuality iosAudioQuality)
+    : directory(directory),
+      subDirectory(subDirectory),
+      fileNamePrefix(fileNamePrefix),
+      channelCount(channelCount),
+      batchDurationSeconds(batchDurationSeconds),
+      format(format),
+      sampleRate(sampleRate),
+      bitRate(bitRate),
+      bitDepth(bitDepth),
+      flacCompressionLevel(flacCompressionLevel),
+      iosAudioQuality(iosAudioQuality) {}
+
+std::shared_ptr<AudioFileProperties> AudioFileProperties::CreateFromJSIValue(
+    facebook::jsi::Runtime &runtime,
+    const facebook::jsi::Value &value) {
+  auto options = value.getObject(runtime);
+
+  FileDirectory directory = static_cast<FileDirectory>(
+      options.getProperty(runtime, "directory").getNumber());
+
+  std::string subDirectory = options.getProperty(runtime, "subDirectory")
+                                 .asString(runtime)
+                                 .utf8(runtime);
+
+  std::string fileNamePrefix = options.getProperty(runtime, "fileNamePrefix")
+                                   .asString(runtime)
+                                   .utf8(runtime);
+
+  size_t channelCount = static_cast<size_t>(
+      options.getProperty(runtime, "channelCount").getNumber());
+
+  size_t batchDurationSeconds = static_cast<size_t>(
+      options.getProperty(runtime, "batchDurationSeconds").getNumber());
+
+  Format format =
+      static_cast<Format>(options.getProperty(runtime, "format").getNumber());
+
+  auto presetOptions =
+      options.getProperty(runtime, "preset").getObject(runtime);
+
+  size_t sampleRate = static_cast<size_t>(
+      presetOptions.getProperty(runtime, "sampleRate").getNumber());
+
+  size_t bitRate = static_cast<size_t>(
+      presetOptions.getProperty(runtime, "bitRate").getNumber());
+
+  BitDepth bitDepth = static_cast<BitDepth>(
+      presetOptions.getProperty(runtime, "bitDepth").getNumber());
+
+  int flacCompressionLevel = static_cast<int>(
+      presetOptions.getProperty(runtime, "flacCompressionLevel").getNumber());
+
+  IOSAudioQuality iosAudioQuality = static_cast<IOSAudioQuality>(
+      presetOptions.getProperty(runtime, "iosQuality").getNumber());
+
+  return std::make_shared<AudioFileProperties>(
+      directory,
+      subDirectory,
+      fileNamePrefix,
+      channelCount,
+      batchDurationSeconds,
+      format,
+      sampleRate,
+      bitRate,
+      bitDepth,
+      std::max(flacCompressionLevel - 1, 0),
+      iosAudioQuality);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h
new file mode 100644
index 000000000..6559dfe54
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/AudioFileProperties.h
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <cstddef>
+
+namespace facebook {
+namespace jsi {
+class Runtime;
+class Value;
+}
+}
+
+namespace audioapi {
+
+class AudioFileProperties {
+ public:
+  enum class Format {
+    WAV = 1,
+    CAF = 2,
+    M4A = 3,
+    FLAC = 4,
+  };
+
+  enum class BitDepth {
+    Bit16 = 1,
+    Bit24 = 2,
+    Bit32 = 3,
+  };
+
+  enum class IOSAudioQuality {
+    Min = 1,
+    Low = 2,
+    Medium = 3,
+    High = 4,
+    Max = 5,
+  };
+
+  enum class FileDirectory {
+    Document = 1,
+    Cache = 2,
+  };
+
+  AudioFileProperties(
+    FileDirectory directory,
+    const std::string &subDirectory,
+    const std::string &fileNamePrefix,
+    size_t channelCount,
+    size_t batchDurationSeconds,
+    Format format,
+    size_t sampleRate,
+    size_t bitRate,
+    BitDepth bitDepth,
+    int flacCompressionLevel,
+    IOSAudioQuality iosAudioQuality);
+
+  static std::shared_ptr<AudioFileProperties> CreateFromJSIValue(
+      facebook::jsi::Runtime &runtime,
+      const facebook::jsi::Value &value);
+
+
+  FileDirectory directory;
+  std::string subDirectory;
+  std::string fileNamePrefix;
+  size_t channelCount;
+  size_t batchDurationSeconds;
+  Format format;
+  size_t sampleRate;
+  size_t bitRate;
+  BitDepth bitDepth;
+  int flacCompressionLevel;
+  IOSAudioQuality iosAudioQuality;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/ReturnStatus.hpp b/packages/react-native-audio-api/common/cpp/audioapi/utils/ReturnStatus.hpp
new file mode 100644
index 000000000..cf0905be9
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/ReturnStatus.hpp
@@ -0,0 +1,120 @@
+#pragma once
+
+#include <string>
+#include <variant>
+#include <optional>
+#include <map>
+#include <utility>
+#include <cstdint>
+
+namespace audioapi {
+
+using MetaValue = std::variant<int64_t, double, std::string, bool>;
+using MetaMap   = std::map<std::string, MetaValue>;
+
+template<typename T>
+class ReturnStatus {
+ public:
+  enum class Status {
+    Success = 0,
+    Error,
+  };
+
+  static ReturnStatus Success(T value, const std::string &message = "") {
+    ReturnStatus s;
+    s.status_  = Status::Success;
+    s.message_ = message;
+    s.value_   = std::move(value);
+    return s;
+  }
+
+  static ReturnStatus Error(const std::string &message) {
+    ReturnStatus s;
+    s.status_  = Status::Error;
+    s.message_ = message;
+    return s;
+  }
+
+  Status getStatus() const { return status_; }
+  bool isSuccess() const { return status_ == Status::Success; }
+  bool isError() const { return status_ == Status::Error; }
+
+  const std::string &getMessage() const { return message_; }
+
+  T &getValue() { return *value_; }
+  const T &getValue() const { return *value_; }
+
+  bool hasValue() const { return value_.has_value(); }
+
+  MetaMap &getMeta() { return meta_; }
+  const MetaMap &getMeta() const { return meta_; }
+
+  template<typename U>
+  void setMetaValue(const std::string &key, U &&value) {
+    meta_[key] = MetaValue(std::forward<U>(value));
+  }
+
+  template<typename U>
+  const U *getMetaValue(const std::string &key) const {
+    auto it = meta_.find(key);
+    if (it == meta_.end()) return nullptr;
+    return std::get_if<U>(&it->second);
+  }
+
+ private:
+  Status status_{Status::Error};
+  std::string message_;
+  std::optional<T> value_;
+  MetaMap meta_;
+};
+
+template<>
+class ReturnStatus<void> {
+ public:
+  enum class Status {
+    Success = 0,
+    Error,
+  };
+
+  static ReturnStatus Success(const std::string &message = "") {
+    ReturnStatus s;
+    s.status_  = Status::Success;
+    s.message_ = message;
+    return s;
+  }
+
+  static ReturnStatus Error(const std::string &message) {
+    ReturnStatus s;
+    s.status_  = Status::Error;
+    s.message_ = message;
+    return s;
+  }
+
+  Status getStatus() const { return status_; }
+  bool isSuccess() const { return status_ == Status::Success; }
+  bool isError() const { return status_ == Status::Error; }
+
+  const std::string &getMessage() const { return message_; }
+
+  MetaMap &getMeta() { return meta_; }
+  const MetaMap &getMeta() const { return meta_; }
+
+  template<typename U>
+  void setMetaValue(const std::string &key, U &&value) {
+    meta_[key] = MetaValue(std::forward<U>(value));
+  }
+
+  template<typename U>
+  const U *getMetaValue(const std::string &key) const {
+    auto it = meta_.find(key);
+    if (it == meta_.end()) return nullptr;
+    return std::get_if<U>(&it->second);
+  }
+
+ private:
+  Status status_{Status::Error};
+  std::string message_;
+  MetaMap meta_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/AudioAPIModule.mm b/packages/react-native-audio-api/ios/audioapi/ios/AudioAPIModule.mm
index baecd10f2..456678efe 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/AudioAPIModule.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/AudioAPIModule.mm
@@ -59,10 +59,15 @@ - (void)invalidate
   [super invalidate];
 }
 
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_queue_create("com.swmansion.audioapi.MainModuleQueue", DISPATCH_QUEUE_SERIAL);
+}
+
 RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install)
 {
   self.audioSessionManager = [[AudioSessionManager alloc] init];
-  self.audioEngine = [[AudioEngine alloc] initWithAudioSessionManager:self.audioSessionManager];
+  self.audioEngine = [[AudioEngine alloc] init];
   self.lockScreenManager = [[LockScreenManager alloc] initWithAudioAPIModule:self];
   self.notificationManager = [[NotificationManager alloc] initWithAudioAPIModule:self];
 
@@ -118,15 +123,11 @@ - (void)invalidate
     setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
         reject)
 {
-  if (!self.audioSessionManager.shouldManageSession) {
-    [self.audioSessionManager setShouldManageSession:true];
-  }
-  if ([self.audioSessionManager setActive:enabled]) {
-    resolve(@"true");
-    return;
-  }
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    auto success = [self.audioSessionManager setActive:enabled];
 
-  resolve(@"false");
+    resolve(@(success));
+  });
 }
 
 RCT_EXPORT_METHOD(
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h
index 1970485b0..f106dfc73 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as Objective-C++
+#ifdef __OBJC__ // when compiled as Objective-C
 #import <NativeAudioPlayer.h>
 #else // when compiled as C++
 typedef struct objc_object NativeAudioPlayer;
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
index c0018e2a8..72bc0fb7f 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioPlayer.mm
@@ -88,7 +88,7 @@
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
 
-  return isRunning_.load() && [audioEngine isRunning];
+  return isRunning_.load() && [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
 }
 
 void IOSAudioPlayer::cleanup()
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
index 39a2e0b0c..e5d2eafea 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.h
@@ -1,32 +1,64 @@
 #pragma once
 
-#ifdef __OBJC__ // when compiled as Objective-C++
+#ifdef __OBJC__ // when compiled as Objective-C
 #import <NativeAudioRecorder.h>
-#else // when compiled as C++
+#else
+typedef struct objc_object NSURL;
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object AudioBufferList;
 typedef struct objc_object NativeAudioRecorder;
 #endif // __OBJC__
 
 #include <audioapi/core/inputs/AudioRecorder.h>
+#include <audioapi/utils/ReturnStatus.hpp>
+
+#include <mutex>
 
 namespace audioapi {
 
-class AudioBus;
-class CircularAudioArray;
+class FileWriter;
+class RecorderCallback;
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
 
 class IOSAudioRecorder : public AudioRecorder {
  public:
-  IOSAudioRecorder(
-      float sampleRate,
-      int bufferLength,
-      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
-
+  IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
   ~IOSAudioRecorder() override;
 
-  void start() override;
-  void stop() override;
+  ReturnStatus<std::string> start() override;
+  ReturnStatus<std::tuple<std::string, double, double>> stop() override;
+
+  ReturnStatus<std::string> enableFileOutput(std::shared_ptr<AudioFileProperties> properties) override;
+  void disableFileOutput() override;
+
+  void pause() override;
+  void resume() override;
+
+  bool isRecording() const override;
+  bool isPaused() const override;
+  bool isIdle() const override;
+
+  ReturnStatus<void>
+  setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId) override;
+  void clearOnAudioReadyCallback() override;
+
+  void setOnErrorCallback(uint64_t callbackId) override;
+  void clearOnErrorCallback() override;
+
+  double getCurrentDuration() const override;
 
  private:
-  NativeAudioRecorder *audioRecorder_;
+  std::shared_ptr<FileWriter> fileWriter_;
+  std::shared_ptr<RecorderCallback> callback_;
+  std::string filePath_{""};
+
+  std::mutex callbackMutex_;
+  std::mutex fileWriterMutex_;
+
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  NativeAudioRecorder *nativeRecorder_;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
index 54b786e0c..d8e6d7dcd 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/IOSAudioRecorder.mm
@@ -1,70 +1,282 @@
 #import <AVFoundation/AVFoundation.h>
+#import <AudioEngine.h>
+#import <AudioSessionManager.h>
+#import <Foundation/Foundation.h>
+
+#include <unordered_map>
 
 #include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/Locker.h>
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/ios/core/IOSAudioRecorder.h>
+#include <audioapi/ios/core/utils/FileWriter.h>
+#include <audioapi/ios/core/utils/RecorderCallback.h>
+#include <audioapi/ios/system/AudioEngine.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/AudioFileProperties.h>
 #include <audioapi/utils/CircularAudioArray.h>
 #include <audioapi/utils/CircularOverflowableAudioArray.h>
-#include <unordered_map>
 
 namespace audioapi {
 
-IOSAudioRecorder::IOSAudioRecorder(
-    float sampleRate,
-    int bufferLength,
-    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry)
-{
-  AudioReceiverBlock audioReceiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
-    if (isRunning_.load()) {
-      auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[0].mData);
-      writeToBuffers(inputChannel, numFrames);
+IOSAudioRecorder::IOSAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
+    : AudioRecorder(audioEventHandlerRegistry), fileWriter_(nullptr)
+{
+  AudioReceiverBlock receiverBlock = ^(const AudioBufferList *inputBuffer, int numFrames) {
+    if (usesFileOutput()) {
+      if (auto lock = Locker::tryLock(fileWriterMutex_)) {
+        fileWriter_->writeAudioData(inputBuffer, numFrames);
+      }
     }
 
-    while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-      auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-      auto *outputChannel = bus->getChannel(0)->getData();
-
-      circularBuffer_->pop_front(outputChannel, bufferLength_);
-
-      invokeOnAudioReadyCallback(bus, bufferLength_);
+    if (usesCallback()) {
+      if (auto lock = Locker::tryLock(callbackMutex_)) {
+        callback_->receiveAudioData(inputBuffer, numFrames);
+      }
     }
   };
 
-  audioRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:audioReceiverBlock
-                                                         bufferLength:bufferLength
-                                                           sampleRate:sampleRate];
+  nativeRecorder_ = [[NativeAudioRecorder alloc] initWithReceiverBlock:receiverBlock];
 }
 
 IOSAudioRecorder::~IOSAudioRecorder()
 {
   stop();
-  [audioRecorder_ cleanup];
+  [nativeRecorder_ cleanup];
+}
+
+ReturnStatus<std::string> IOSAudioRecorder::start()
+{
+  Locker callbackLock(callbackMutex_);
+  Locker fileWriterLock(fileWriterMutex_);
+  AudioSessionManager *audioSessionManager = [AudioSessionManager sharedInstance];
+
+  if ([[audioSessionManager checkRecordingPermissions] isEqual:@"Denied"]) {
+    return ReturnStatus<std::string>::Error("Microphone permissions are not granted");
+  }
+
+  // TODO: recorder should probably request activating the session and setting the options if not set by user
+  // but lets handle that in another PR
+  if (![audioSessionManager isSessionActive]) {
+    return ReturnStatus<std::string>::Error("Audio session is not active");
+  }
+
+  size_t maxInputBufferLength = [nativeRecorder_ getBufferSize];
+
+  if (isRecording()) {
+    return ReturnStatus<std::string>::Error("Already recording");
+  }
+
+  if (usesFileOutput()) {
+    auto fileResult = fileWriter_->openFile([nativeRecorder_ getInputFormat], maxInputBufferLength);
+
+    if (!fileResult.isSuccess()) {
+      return ReturnStatus<std::string>::Error("Failed to open file for writing: " + fileResult.getMessage());
+    }
+
+    filePath_ = fileResult.getValue();
+  }
+
+  if (usesCallback()) {
+    auto callbackResult = callback_->prepare([nativeRecorder_ getInputFormat], maxInputBufferLength);
+
+    if (!callbackResult.isSuccess()) {
+      return ReturnStatus<std::string>::Error("Failed to prepare callback: " + callbackResult.getMessage());
+    }
+  }
+
+  if (isConnected()) {
+    // TODO: set adapter node properties?
+  }
+
+  [nativeRecorder_ start];
+  state_.store(RecorderState::Recording);
+
+  return ReturnStatus<std::string>::Success(filePath_);
+}
+
+ReturnStatus<std::tuple<std::string, double, double>> IOSAudioRecorder::stop()
+{
+  Locker callbackLock(callbackMutex_);
+  Locker fileWriterLock(fileWriterMutex_);
+
+  std::string filePath = filePath_;
+  double outputFileSize = 0;
+  double outputDuration = 0;
+
+  if (!isRecording()) {
+    return ReturnStatus<std::tuple<std::string, double, double>>::Error("Not recording");
+  }
+
+  state_.store(RecorderState::Idle);
+  [nativeRecorder_ stop];
+
+  if (usesFileOutput()) {
+    auto fileResult = fileWriter_->closeFile();
+
+    if (!fileResult.isSuccess()) {
+      return ReturnStatus<std::tuple<std::string, double, double>>::Error(
+          "Failed to close file: " + fileResult.getMessage());
+    }
+
+    outputFileSize = std::get<0>(fileResult.getValue());
+    outputDuration = std::get<1>(fileResult.getValue());
+  }
+
+  if (usesCallback()) {
+    callback_->cleanup();
+  }
+
+  filePath_ = "";
+  return ReturnStatus<std::tuple<std::string, double, double>>::Success(
+      std::make_tuple(filePath, outputFileSize, outputDuration));
+}
+
+ReturnStatus<std::string> IOSAudioRecorder::enableFileOutput(std::shared_ptr<AudioFileProperties> properties)
+{
+  Locker lock(fileWriterMutex_);
+  fileWriter_ = std::make_shared<FileWriter>(audioEventHandlerRegistry_, properties);
+
+  if (!isIdle()) {
+    auto result = fileWriter_->openFile([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
+
+    if (!result.isSuccess()) {
+      return ReturnStatus<std::string>::Error("Failed to open file for writing: " + result.getMessage());
+    }
+
+    filePath_ = result.getValue();
+  }
+
+  // TODO: atomic szpont?
+  if (errorCallbackId_.load() != 0) {
+    fileWriter_->setOnErrorCallback(errorCallbackId_.load());
+  }
+
+  fileOutputEnabled_.store(true);
+  return ReturnStatus<std::string>::Success(filePath_);
+}
+
+void IOSAudioRecorder::disableFileOutput()
+{
+  Locker lock(fileWriterMutex_);
+  fileOutputEnabled_.store(false);
+  fileWriter_ = nullptr;
 }
 
-void IOSAudioRecorder::start()
+void IOSAudioRecorder::pause()
 {
-  if (isRunning_.load()) {
+  if (!isRecording()) {
     return;
   }
 
-  [audioRecorder_ start];
-  isRunning_.store(true);
+  [nativeRecorder_ pause];
+  state_.store(RecorderState::Paused);
 }
 
-void IOSAudioRecorder::stop()
+void IOSAudioRecorder::resume()
 {
-  if (!isRunning_.load()) {
+  if (!isPaused()) {
     return;
   }
 
-  isRunning_.store(false);
-  [audioRecorder_ stop];
+  [nativeRecorder_ resume];
+  state_.store(RecorderState::Recording);
+}
+
+bool IOSAudioRecorder::isRecording() const
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  return state_.load() == RecorderState::Recording &&
+      [audioEngine getState] == AudioEngineState::AudioEngineStateRunning;
+}
+
+bool IOSAudioRecorder::isPaused() const
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  auto currentState = state_.load();
+
+  if (currentState == RecorderState::Idle) {
+    return false;
+  }
+
+  return currentState == RecorderState::Paused && [audioEngine getState] != AudioEngineState::AudioEngineStateRunning;
+}
+
+bool IOSAudioRecorder::isIdle() const
+{
+  return state_.load() == RecorderState::Idle;
+}
+
+ReturnStatus<void> IOSAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+{
+  Locker lock(callbackMutex_);
+
+  callback_ = std::make_shared<RecorderCallback>(
+      audioEventHandlerRegistry_, sampleRate, bufferLength, channelCount, callbackId);
+
+  if (!isIdle()) {
+    auto result = callback_->prepare([nativeRecorder_ getInputFormat], [nativeRecorder_ getBufferSize]);
+
+    if (!result.isSuccess()) {
+      return ReturnStatus<void>::Error(result.getMessage());
+    }
+  }
+
+  if (errorCallbackId_.load() != 0) {
+    callback_->setOnErrorCallback(errorCallbackId_.load());
+  }
+
+  callbackOutputEnabled_.store(true);
+  return ReturnStatus<void>::Success();
+}
+
+void IOSAudioRecorder::clearOnAudioReadyCallback()
+{
+  Locker lock(callbackMutex_);
+  callbackOutputEnabled_.store(false);
+  callback_ = nullptr;
+}
+
+void IOSAudioRecorder::setOnErrorCallback(uint64_t callbackId)
+{
+  if (usesFileOutput()) {
+    fileWriter_->setOnErrorCallback(callbackId);
+  }
+
+  if (usesCallback()) {
+    callback_->setOnErrorCallback(callbackId);
+  }
+  errorCallbackId_.store(callbackId);
+}
+
+void IOSAudioRecorder::clearOnErrorCallback()
+{
+  errorCallbackId_.store(0);
+
+  if (usesFileOutput()) {
+    fileWriter_->clearOnErrorCallback();
+  }
+
+  if (usesCallback()) {
+    callback_->clearOnErrorCallback();
+  }
+}
+
+double IOSAudioRecorder::getCurrentDuration() const
+{
+  double duration = 0.0;
+
+  if (usesFileOutput() && fileWriter_) {
+    duration = fileWriter_->getCurrentDuration();
+  }
 
-  sendRemainingData();
+  return duration;
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioPlayer.m b/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioPlayer.m
index 052777208..da6eb90e1 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioPlayer.m
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioPlayer.m
@@ -34,8 +34,6 @@ - (instancetype)initWithRenderAudio:(RenderAudioBlock)renderAudio
 
 - (bool)start
 {
-  NSLog(@"[AudioPlayer] start");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -46,17 +44,16 @@ - (bool)start
   //
   // Currently we are restarting because we do not see any significant performance issue and case when
   // you will need to start and stop player very frequently
-  [audioEngine stopEngine];
+  [audioEngine stopIfNecessary];
   self.sourceNodeId = [audioEngine attachSourceNode:self.sourceNode format:self.format];
   return [audioEngine startIfNecessary];
 }
 
 - (void)stop
 {
-  NSLog(@"[AudioPlayer] stop");
-
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
+
   [audioEngine detachSourceNodeWithId:self.sourceNodeId];
   [audioEngine stopIfNecessary];
   self.sourceNodeId = nil;
@@ -64,7 +61,6 @@ - (void)stop
 
 - (bool)resume
 {
-  NSLog(@"[AudioPlayer] resume");
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
 
@@ -75,7 +71,8 @@ - (void)suspend
 {
   AudioEngine *audioEngine = [AudioEngine sharedInstance];
   assert(audioEngine != nil);
-  [audioEngine pauseEngine:self.sourceNodeId];
+
+  [audioEngine pauseIfNecessary];
 }
 
 - (void)cleanup
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.h b/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.h
index 6e4f8f1c0..bb987fb50 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.h
@@ -7,25 +7,24 @@ typedef void (^AudioReceiverBlock)(const AudioBufferList *inputBuffer, int numFr
 
 @interface NativeAudioRecorder : NSObject
 
-@property (nonatomic, assign) int bufferLength;
-@property (nonatomic, assign) float sampleRate;
-
 @property (nonatomic, strong) AVAudioSinkNode *sinkNode;
 @property (nonatomic, copy) AVAudioSinkNodeReceiverBlock receiverSinkBlock;
 @property (nonatomic, copy) AudioReceiverBlock receiverBlock;
 
-@property (nonatomic, strong) AVAudioConverter *audioConverter;
-@property (nonatomic, strong) AVAudioFormat *inputFormat;
-@property (nonatomic, strong) AVAudioFormat *outputFormat;
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock;
+
+- (AVAudioFormat *)getInputFormat;
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate;
+- (int)getBufferSize;
 
 - (void)start;
 
 - (void)stop;
 
+- (void)pause;
+
+- (void)resume;
+
 - (void)cleanup;
 
 @end
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.m b/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.m
index 9574115a2..f18631660 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.m
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/NativeAudioRecorder.m
@@ -4,41 +4,36 @@
 
 @implementation NativeAudioRecorder
 
-- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
-                         bufferLength:(int)bufferLength
-                           sampleRate:(float)sampleRate
+static inline uint32_t nextPowerOfTwo(uint32_t x)
 {
-  if (self = [super init]) {
-    self.bufferLength = bufferLength;
-    self.sampleRate = sampleRate;
-
-    self.receiverBlock = [receiverBlock copy];
-
-    float devicePrefferedSampleRate = [[AVAudioSession sharedInstance] sampleRate];
+  if (x == 0) {
+    return 1;
+  }
 
-    if (!devicePrefferedSampleRate) {
-      NSError *error;
-      devicePrefferedSampleRate = sampleRate;
+  x--;
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  x++;
 
-      [[AVAudioSession sharedInstance] setPreferredSampleRate:sampleRate error:&error];
-    }
+  return x;
+}
 
-    self.inputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                        sampleRate:devicePrefferedSampleRate
-                                                          channels:1
-                                                       interleaved:NO];
-    self.outputFormat = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
-                                                         sampleRate:sampleRate
-                                                           channels:1
-                                                        interleaved:NO];
-    self.audioConverter = [[AVAudioConverter alloc] initFromFormat:self.inputFormat toFormat:self.outputFormat];
+- (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
+{
+  if (self = [super init]) {
+    self.receiverBlock = [receiverBlock copy];
 
     __weak typeof(self) weakSelf = self;
     self.receiverSinkBlock = ^OSStatus(
         const AudioTimeStamp *_Nonnull timestamp,
         AVAudioFrameCount frameCount,
         const AudioBufferList *_Nonnull inputData) {
-      return [weakSelf processAudioInput:inputData withFrameCount:frameCount atTimestamp:timestamp];
+      weakSelf.receiverBlock(inputData, frameCount);
+
+      return kAudioServicesNoError;
     };
 
     self.sinkNode = [[AVAudioSinkNode alloc] initWithReceiverBlock:self.receiverSinkBlock];
@@ -47,55 +42,24 @@ - (instancetype)initWithReceiverBlock:(AudioReceiverBlock)receiverBlock
   return self;
 }
 
-- (OSStatus)processAudioInput:(const AudioBufferList *)inputData
-               withFrameCount:(AVAudioFrameCount)frameCount
-                  atTimestamp:(const AudioTimeStamp *)timestamp
+- (AVAudioFormat *)getInputFormat
 {
-  float inputSampleRate = self.inputFormat.sampleRate;
-  float outputSampleRate = self.outputFormat.sampleRate;
-
-  if (inputSampleRate != outputSampleRate) {
-    AVAudioPCMBuffer *inputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.inputFormat
-                                                                  frameCapacity:frameCount];
-    memcpy(
-        inputBuffer.mutableAudioBufferList->mBuffers[0].mData,
-        inputData->mBuffers[0].mData,
-        inputData->mBuffers[0].mDataByteSize);
-    inputBuffer.frameLength = frameCount;
-
-    int outputFrameCount = frameCount * outputSampleRate / inputSampleRate;
-
-    AVAudioPCMBuffer *outputBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:self.audioConverter.outputFormat
-                                                                   frameCapacity:outputFrameCount];
-
-    NSError *error = nil;
-    AVAudioConverterInputBlock inputBlock =
-        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
-    {
-      *outStatus = AVAudioConverterInputStatus_HaveData;
-      return inputBuffer;
-    };
-
-    /// IMPORTANT: AVAudioConverter leaks memory without autorelease pool
-    /// more details here: https://github.com/poneciak57/AVAudioConverter-memory-leak-repro-electric-boogaloo
-    /// we can try to remove it in the future or refactor to reuse buffers to minimize allocations
-    @autoreleasepool {
-      [self.audioConverter convertToBuffer:outputBuffer error:&error withInputFromBlock:inputBlock];
-    }
-
-    if (error) {
-      NSLog(@"Error during audio conversion: %@", error.localizedDescription);
-      return kAudioServicesBadSpecifierSizeError;
-    }
-
-    self.receiverBlock(outputBuffer.audioBufferList, outputBuffer.frameLength);
+  return [AudioEngine.sharedInstance.audioEngine.inputNode inputFormatForBus:0];
+}
 
-    return kAudioServicesNoError;
-  }
+- (int)getBufferSize
+{
+  // NOTE: this method should be called only after the session is activated
+  AVAudioSession *audioSession = [AVAudioSession sharedInstance];
 
-  self.receiverBlock(inputData, frameCount);
+  // TMPfix: it seems that buffer duration in some cases (background/device change) can switch
+  // to longer values, exceeding buffer size predicted after session start
+  // since it is just a couple of buffers we can set min value of 200ms
+  // to enforce we always have enough frames allocated to pass further down the pipeline
+  float bufferDuration = MAX(audioSession.IOBufferDuration, 0.2);
 
-  return kAudioServicesNoError;
+  // IOS returns buffer duration rounded, but expects the buffer size to be power of two in runtime
+  return nextPowerOfTwo(ceil(bufferDuration * audioSession.sampleRate));
 }
 
 - (void)start
@@ -110,7 +74,7 @@ - (void)start
   //
   // Currently we are restarting because we do not see any significant performance issue and case when
   // you will need to start and stop recorder very frequently
-  [audioEngine stopEngine];
+  [audioEngine stopIfNecessary];
   [audioEngine attachInputNode:self.sinkNode];
   [audioEngine startIfNecessary];
 }
@@ -123,6 +87,22 @@ - (void)stop
   [audioEngine stopIfNecessary];
 }
 
+- (void)pause
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+
+  [audioEngine pauseIfNecessary];
+}
+
+- (void)resume
+{
+  AudioEngine *audioEngine = [AudioEngine sharedInstance];
+  assert(audioEngine != nil);
+
+  [audioEngine startIfNecessary];
+}
+
 - (void)cleanup
 {
   self.receiverBlock = nil;
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/AudioDecoder.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/AudioDecoder.mm
index 9c47fca51..4e90455bd 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/AudioDecoder.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/AudioDecoder.mm
@@ -59,6 +59,7 @@
       channelData[i] = buffer[i * outputChannels + ch];
     }
   }
+
   return std::make_shared<AudioBuffer>(audioBus);
 }
 
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.h b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.h
new file mode 100644
index 000000000..da3a1c222
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object NSURL;
+typedef struct objc_object AudioBufferList;
+#endif // __OBJC__
+
+namespace audioapi {
+
+class AudioFileProperties;
+
+namespace ios::fileoptions {
+
+AudioFormatID getFormat(const std::shared_ptr<AudioFileProperties> &properties);
+NSInteger getQuality(const std::shared_ptr<AudioFileProperties> &properties);
+NSInteger getFlacCompressionLevel(const std::shared_ptr<AudioFileProperties> &properties);
+NSString *getFileExtension(const std::shared_ptr<AudioFileProperties> &properties);
+NSInteger getBitDepth(const std::shared_ptr<AudioFileProperties> &properties);
+float getSampleRate(const std::shared_ptr<AudioFileProperties> &properties);
+
+NSDictionary *getFileSettings(const std::shared_ptr<AudioFileProperties> &properties);
+NSURL *getFileURL(const std::shared_ptr<AudioFileProperties> &properties);
+NSSearchPathDirectory getDirectory(const std::shared_ptr<AudioFileProperties> &properties);
+
+NSString *getDateString();
+NSString *getTimestampString();
+
+} // namespace ios::fileoptions
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm
new file mode 100644
index 000000000..b39bd40b9
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileOptions.mm
@@ -0,0 +1,175 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/utils/AudioFileProperties.h>
+
+namespace audioapi::ios::fileoptions {
+
+AudioFormatID getFormat(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return kAudioFormatLinearPCM;
+
+    case AudioFileProperties::Format::CAF:
+      return kAudioFormatLinearPCM;
+
+    case AudioFileProperties::Format::M4A:
+      return kAudioFormatMPEG4AAC;
+
+    case AudioFileProperties::Format::FLAC:
+      return kAudioFormatFLAC;
+
+    default:
+      return kAudioFormatLinearPCM;
+  }
+}
+
+NSInteger getQuality(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->iosAudioQuality) {
+    case AudioFileProperties::IOSAudioQuality::Min:
+      return AVAudioQualityMin;
+
+    case AudioFileProperties::IOSAudioQuality::Low:
+      return AVAudioQualityLow;
+
+    case AudioFileProperties::IOSAudioQuality::Medium:
+      return AVAudioQualityMedium;
+
+    case AudioFileProperties::IOSAudioQuality::High:
+      return AVAudioQualityHigh;
+
+    case AudioFileProperties::IOSAudioQuality::Max:
+      return AVAudioQualityMax;
+
+    default:
+      return AVAudioQualityMedium;
+  }
+}
+
+NSInteger getFlacCompressionLevel(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  return properties->flacCompressionLevel;
+}
+
+NSString *getFileExtension(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->format) {
+    case AudioFileProperties::Format::WAV:
+      return @"wav";
+
+    case AudioFileProperties::Format::CAF:
+      return @"caf";
+
+    case AudioFileProperties::Format::M4A:
+      return @"m4a";
+
+    case AudioFileProperties::Format::FLAC:
+      return @"flac";
+
+    default:
+      return @"wav";
+  }
+}
+
+NSInteger getBitDepth(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->bitDepth) {
+    case AudioFileProperties::BitDepth::Bit16:
+      return 16;
+
+    case AudioFileProperties::BitDepth::Bit24:
+      return 24;
+
+    case AudioFileProperties::BitDepth::Bit32:
+      return 32;
+
+    default:
+      return 32;
+  }
+}
+
+NSDictionary *getFileSettings(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  AudioFormatID format = getFormat(properties);
+  NSMutableDictionary *settings = [NSMutableDictionary dictionary];
+
+  settings[AVFormatIDKey] = @(format);
+  settings[AVSampleRateKey] = @(properties->sampleRate);
+  settings[AVNumberOfChannelsKey] = @(properties->channelCount);
+  settings[AVEncoderAudioQualityKey] = @(getQuality(properties));
+
+  if (format == kAudioFormatMPEG4AAC) {
+    settings[AVEncoderBitRateKey] = @(properties->bitRate);
+  }
+
+  if (format == kAudioFormatLinearPCM) {
+    NSInteger bitDepth = getBitDepth(properties);
+
+    settings[AVLinearPCMBitDepthKey] = @(bitDepth);
+    settings[AVLinearPCMIsFloatKey] = @(bitDepth == 32);
+    settings[AVLinearPCMIsBigEndianKey] = @(NO);
+    settings[AVLinearPCMIsNonInterleaved] = @(NO);
+  }
+
+  if (format == kAudioFormatFLAC) {
+    settings[@"FLACCompressionLevel"] = @(getFlacCompressionLevel(properties));
+  }
+
+  return settings;
+}
+
+NSURL *getFileURL(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  NSError *error = nil;
+
+  NSSearchPathDirectory directory = getDirectory(properties);
+  NSString *subDirectory = [NSString stringWithUTF8String:properties->subDirectory.c_str()];
+
+  NSURL *baseURL = [[[NSFileManager defaultManager] URLsForDirectory:directory inDomains:NSUserDomainMask] firstObject];
+  NSURL *directoryURL = [baseURL URLByAppendingPathComponent:subDirectory isDirectory:YES];
+
+  [[NSFileManager defaultManager] createDirectoryAtURL:directoryURL
+                           withIntermediateDirectories:YES
+                                            attributes:nil
+                                                 error:&error];
+
+  if (error != nil) {
+    NSLog(@"Error creating directory for audio recordings: %@", [error debugDescription]);
+    directoryURL = baseURL;
+  }
+
+  NSString *fileNamePrefix = [NSString stringWithUTF8String:properties->fileNamePrefix.c_str()];
+  NSString *timestamp = getTimestampString();
+  NSString *fileExtension = getFileExtension(properties);
+
+  NSString *fileName = [NSString stringWithFormat:@"%@_%@.%@", fileNamePrefix, timestamp, fileExtension];
+  return [directoryURL URLByAppendingPathComponent:fileName];
+}
+
+NSSearchPathDirectory getDirectory(const std::shared_ptr<AudioFileProperties> &properties)
+{
+  switch (properties->directory) {
+    case AudioFileProperties::FileDirectory::Document:
+      return NSDocumentDirectory;
+
+    case AudioFileProperties::FileDirectory::Cache:
+      return NSCachesDirectory;
+
+    default:
+      return NSCachesDirectory;
+  }
+}
+
+NSString *getTimestampString()
+{
+  NSDateFormatter *fmt = [[NSDateFormatter alloc] init];
+  fmt.locale = [NSLocale localeWithLocaleIdentifier:@"en_US_POSIX"];
+  fmt.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"UTC"]; // or local if you prefer
+  fmt.dateFormat = @"yyyyMMdd_HHmmss_SSS";
+  return [fmt stringFromDate:[NSDate date]];
+}
+
+} // namespace audioapi::ios::fileoptions
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.h b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.h
new file mode 100644
index 000000000..2211a4d43
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.h
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <audioapi/utils/ReturnStatus.hpp>
+
+#include <memory>
+#include <string>
+#include <tuple>
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object NSURL;
+typedef struct objc_object NSString;
+typedef struct objc_object AVAudioFile;
+typedef struct objc_object AVAudioFormat;
+typedef struct objc_object AudioBufferList;
+typedef struct objc_object AVAudioConverter;
+#endif // __OBJC__
+
+namespace audioapi {
+
+class AudioFileProperties;
+class AudioEventHandlerRegistry;
+
+class FileWriter {
+ public:
+  FileWriter(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const std::shared_ptr<AudioFileProperties> &fileProperties);
+  ~FileWriter();
+
+  ReturnStatus<std::string> openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  ReturnStatus<std::tuple<double, double>> closeFile();
+
+  bool writeAudioData(const AudioBufferList *audioBufferList, int numFrames);
+
+  double getCurrentDuration() const;
+  std::string getFilePath() const;
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ private:
+  size_t converterInputBufferSize_;
+  size_t converterOutputBufferSize_;
+  std::atomic<size_t> framesWritten_{0};
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioFileProperties> fileProperties_;
+  AVAudioFile *audioFile_;
+  AVAudioFormat *bufferFormat_;
+  AVAudioConverter *converter_;
+  NSURL *fileURL_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.mm
new file mode 100644
index 000000000..78a9043b1
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/FileWriter.mm
@@ -0,0 +1,236 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/ios/core/utils/FileOptions.h>
+#include <audioapi/ios/core/utils/FileWriter.h>
+#include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/utils/ReturnStatus.hpp>
+
+constexpr double BYTES_TO_MB = 1024.0 * 1024.0;
+
+namespace audioapi {
+FileWriter::FileWriter(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<AudioFileProperties> &fileProperties)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry), fileProperties_(fileProperties)
+{
+}
+
+FileWriter::~FileWriter()
+{
+  fileURL_ = nil;
+  audioFile_ = nil;
+  converter_ = nil;
+  bufferFormat_ = nil;
+}
+
+ReturnStatus<std::string> FileWriter::openFile(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    if (audioFile_ != nil) {
+      return ReturnStatus<std::string>::Error("file already open");
+    }
+
+    framesWritten_.store(0);
+    bufferFormat_ = bufferFormat;
+
+    NSError *error = nil;
+    NSDictionary *settings = ios::fileoptions::getFileSettings(fileProperties_);
+    fileURL_ = ios::fileoptions::getFileURL(fileProperties_);
+
+    if (fileProperties_->sampleRate == 0 || fileProperties_->channelCount == 0) {
+      return ReturnStatus<std::string>::Error(
+          "Invalid file properties: sampleRate and channelCount must be greater than 0");
+    }
+
+    if (bufferFormat.sampleRate == 0 || bufferFormat.channelCount == 0) {
+      return ReturnStatus<std::string>::Error(
+          "Invalid input format: sampleRate and channelCount must be greater than 0");
+    }
+
+    audioFile_ = [[AVAudioFile alloc] initForWriting:fileURL_
+                                            settings:settings
+                                        commonFormat:AVAudioPCMFormatFloat32
+                                         interleaved:bufferFormat.interleaved
+                                               error:&error];
+
+    if (error != nil) {
+      return ReturnStatus<std::string>::Error(
+          std::string("Error creating audio file for writing: ") + [[error debugDescription] UTF8String]);
+    }
+
+    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat toFormat:[audioFile_ processingFormat]];
+    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    converter_.sampleRateConverterQuality = AVAudioQualityMax;
+    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    converterInputBufferSize_ = maxInputBufferLength;
+    converterOutputBufferSize_ = std::max(
+        (double)maxInputBufferLength, fileProperties_->sampleRate / bufferFormat.sampleRate * maxInputBufferLength);
+
+    converterInputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat
+                                                          frameCapacity:(AVAudioFrameCount)maxInputBufferLength];
+    converterOutputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:[audioFile_ processingFormat]
+                                                           frameCapacity:(AVAudioFrameCount)converterOutputBufferSize_];
+
+    if (converterInputBuffer_ == nil || converterOutputBuffer_ == nil || audioFile_ == nil || converter_ == nil) {
+      audioFile_ = nil;
+      converter_ = nil;
+      converterInputBuffer_ = nil;
+      converterOutputBuffer_ = nil;
+
+      return ReturnStatus<std::string>::Error("Error creating converter buffers");
+    }
+
+    return ReturnStatus<std::string>::Success([[fileURL_ path] UTF8String]);
+  }
+}
+
+ReturnStatus<std::tuple<double, double>> FileWriter::closeFile()
+{
+  @autoreleasepool {
+    NSError *error;
+    std::string filePath = [[fileURL_ path] UTF8String];
+
+    if (audioFile_ == nil) {
+      return ReturnStatus<std::tuple<double, double>>::Error("file is not open: " + filePath);
+    }
+
+    // AVAudioFile automatically finalizes the file when deallocated
+    audioFile_ = nil;
+
+    double fileDuration = CMTimeGetSeconds([[AVURLAsset URLAssetWithURL:fileURL_ options:nil] duration]);
+    double fileSizeBytesMb =
+        static_cast<double>([[[NSFileManager defaultManager] attributesOfItemAtPath:fileURL_.path
+                                                                              error:&error] fileSize]) /
+        BYTES_TO_MB;
+
+    if (error != nil) {
+      NSLog(@"⚠️ closeFile: error while retrieving file size");
+      fileSizeBytesMb = 0;
+    }
+
+    fileURL_ = nil;
+    framesWritten_.store(0);
+
+    return ReturnStatus<std::tuple<double, double>>::Success(std::make_tuple(fileDuration, fileSizeBytesMb));
+  }
+}
+
+bool FileWriter::writeAudioData(const AudioBufferList *audioBufferList, int numFrames)
+{
+  if (audioFile_ == nil) {
+    invokeOnErrorCallback("Attempted to write audio data when file is not open");
+    return false;
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+    AVAudioFormat *fileFormat = [audioFile_ processingFormat];
+
+    if (bufferFormat_.sampleRate == fileFormat.sampleRate && bufferFormat_.channelCount == fileFormat.channelCount &&
+        bufferFormat_.isInterleaved == fileFormat.isInterleaved) {
+      // We can use the converter input buffer as a "transport" layer to the file
+      for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+        memcpy(
+            converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+            audioBufferList->mBuffers[i].mData,
+            audioBufferList->mBuffers[i].mDataByteSize);
+      }
+      converterInputBuffer_.frameLength = numFrames;
+
+      [audioFile_ writeFromBuffer:converterInputBuffer_ error:&error];
+
+      if (error != nil) {
+        invokeOnErrorCallback(
+            std::string("Error writing audio data to file, native error: ") + [[error debugDescription] UTF8String]);
+        return false;
+      }
+
+      framesWritten_.fetch_add(numFrames);
+      return true;
+    }
+
+    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+      memcpy(
+          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mData,
+          audioBufferList->mBuffers[i].mDataByteSize);
+    }
+
+    converterInputBuffer_.frameLength = numFrames;
+
+    __block BOOL handedOff = false;
+    AVAudioConverterInputBlock inputBlock =
+        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      if (handedOff) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+
+      handedOff = true;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
+
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
+    converterOutputBuffer_.frameLength = fileProperties_->sampleRate / bufferFormat_.sampleRate * numFrames;
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error during audio conversion, native error: ") + [[error debugDescription] UTF8String]);
+      return false;
+    }
+
+    [audioFile_ writeFromBuffer:converterOutputBuffer_ error:&error];
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error writing audio data to file, native error: ") + [[error debugDescription] UTF8String]);
+      return false;
+    }
+
+    framesWritten_.fetch_add(numFrames);
+    return true;
+  }
+}
+
+double FileWriter::getCurrentDuration() const
+{
+  return static_cast<double>(framesWritten_.load()) / bufferFormat_.sampleRate;
+}
+
+std::string FileWriter::getFilePath() const
+{
+  return [[fileURL_ path] UTF8String];
+}
+
+void FileWriter::setOnErrorCallback(uint64_t callbackId)
+{
+  errorCallbackId_.store(callbackId);
+}
+
+void FileWriter::clearOnErrorCallback()
+{
+  errorCallbackId_.store(0);
+}
+
+void FileWriter::invokeOnErrorCallback(const std::string &message)
+{
+  uint64_t callbackId = errorCallbackId_.load();
+
+  // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
+  // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.
+  // TL;DR: atomic szpont
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.h b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.h
new file mode 100644
index 000000000..85cb3d8b0
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#ifndef __OBJC__ // when compiled as C++
+typedef struct objc_object AVAudioFormat;
+typedef struct objc_object AudioBufferList;
+typedef struct objc_object AVAudioConverter;
+#endif
+
+#include <audioapi/utils/ReturnStatus.hpp>
+#include <memory>
+#include <vector>
+
+namespace audioapi {
+
+class AudioBus;
+class CircularAudioArray;
+class AudioEventHandlerRegistry;
+
+class RecorderCallback {
+ public:
+  RecorderCallback(
+      const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      float sampleRate,
+      size_t bufferLength,
+      size_t channelCount,
+      uint64_t callbackId);
+  ~RecorderCallback();
+
+  ReturnStatus<void> prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength);
+  void cleanup();
+
+  void receiveAudioData(const AudioBufferList *audioBufferList, int numFrames);
+  void emitAudioData();
+
+  void invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames);
+  void sendRemainingData();
+
+  void setOnErrorCallback(uint64_t callbackId);
+  void clearOnErrorCallback();
+  void invokeOnErrorCallback(const std::string &message);
+
+ private:
+  std::atomic<bool> isInitialized_{false};
+
+  float sampleRate_;
+  size_t bufferLength_;
+  size_t channelCount_;
+  uint64_t callbackId_;
+  size_t ringBufferSize_;
+  size_t converterInputBufferSize_;
+  size_t converterOutputBufferSize_;
+
+  std::atomic<uint64_t> errorCallbackId_{0};
+
+  std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
+  std::vector<std::shared_ptr<CircularAudioArray>> circularBus_;
+
+  AVAudioFormat *bufferFormat_;
+  AVAudioFormat *callbackFormat_;
+  AVAudioConverter *converter_;
+
+  AVAudioPCMBuffer *converterInputBuffer_;
+  AVAudioPCMBuffer *converterOutputBuffer_;
+};
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.mm b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.mm
new file mode 100644
index 000000000..c347f586a
--- /dev/null
+++ b/packages/react-native-audio-api/ios/audioapi/ios/core/utils/RecorderCallback.mm
@@ -0,0 +1,240 @@
+#import <AVFoundation/AVFoundation.h>
+#import <Foundation/Foundation.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/dsp/VectorMath.h>
+#include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/ios/core/utils/RecorderCallback.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+#include <audioapi/utils/CircularAudioArray.h>
+#include <audioapi/utils/ReturnStatus.hpp>
+#include <algorithm>
+
+namespace audioapi {
+
+RecorderCallback::RecorderCallback(
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId)
+    : audioEventHandlerRegistry_(audioEventHandlerRegistry),
+      sampleRate_(sampleRate),
+      bufferLength_(bufferLength),
+      channelCount_(channelCount),
+      callbackId_(callbackId)
+{
+  ringBufferSize_ = std::max((int)bufferLength_ * 2, 8192);
+  circularBus_.resize(channelCount_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto busAudioArray = std::make_shared<CircularAudioArray>(ringBufferSize_);
+    circularBus_[i] = busAudioArray;
+  }
+
+  isInitialized_.store(true);
+}
+
+RecorderCallback::~RecorderCallback()
+{
+  isInitialized_.store(false);
+  @autoreleasepool {
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      circularBus_[i].reset();
+    }
+  }
+}
+
+ReturnStatus<void> RecorderCallback::prepare(AVAudioFormat *bufferFormat, size_t maxInputBufferLength)
+{
+  @autoreleasepool {
+    bufferFormat_ = bufferFormat;
+    converterInputBufferSize_ = maxInputBufferLength;
+
+    if (bufferFormat.sampleRate <= 0 || bufferFormat.channelCount == 0) {
+      return ReturnStatus<void>::Error("Invalid input format: sampleRate and channelCount must be greater than 0");
+    }
+
+    if (sampleRate_ <= 0 || channelCount_ == 0) {
+      return ReturnStatus<void>::Error("Invalid callback format: sampleRate and channelCount must be greater than 0");
+    }
+
+    converterOutputBufferSize_ =
+        std::max((double)maxInputBufferLength, sampleRate_ / bufferFormat.sampleRate * maxInputBufferLength);
+
+    callbackFormat_ = [[AVAudioFormat alloc] initWithCommonFormat:AVAudioPCMFormatFloat32
+                                                       sampleRate:sampleRate_
+                                                         channels:channelCount_
+                                                      interleaved:NO];
+
+    converter_ = [[AVAudioConverter alloc] initFromFormat:bufferFormat toFormat:callbackFormat_];
+    converter_.sampleRateConverterAlgorithm = AVSampleRateConverterAlgorithm_Normal;
+    converter_.sampleRateConverterQuality = AVAudioQualityMax;
+    converter_.primeMethod = AVAudioConverterPrimeMethod_None;
+
+    converterInputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:bufferFormat_
+                                                          frameCapacity:(AVAudioFrameCount)converterInputBufferSize_];
+    converterOutputBuffer_ = [[AVAudioPCMBuffer alloc] initWithPCMFormat:callbackFormat_
+                                                           frameCapacity:(AVAudioFrameCount)converterOutputBufferSize_];
+  }
+
+  return ReturnStatus<void>::Success();
+}
+
+void RecorderCallback::cleanup()
+{
+  @autoreleasepool {
+    sendRemainingData();
+
+    converter_ = nil;
+    bufferFormat_ = nil;
+    callbackFormat_ = nil;
+    converterInputBuffer_ = nil;
+    converterOutputBuffer_ = nil;
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      circularBus_[i]->zero();
+    }
+  }
+}
+
+void RecorderCallback::receiveAudioData(const AudioBufferList *inputBuffer, int numFrames)
+{
+  if (!isInitialized_.load()) {
+    return;
+  }
+
+  @autoreleasepool {
+    NSError *error = nil;
+
+    if (bufferFormat_.sampleRate == sampleRate_ && bufferFormat_.channelCount == channelCount_ &&
+        !bufferFormat_.isInterleaved) {
+      // Directly write to circular buffer
+      for (size_t i = 0; i < channelCount_; ++i) {
+        auto *inputChannel = static_cast<float *>(inputBuffer->mBuffers[i].mData);
+        circularBus_[i]->push_back(inputChannel, numFrames);
+      }
+
+      emitAudioData();
+      return;
+    }
+
+    size_t outputFrameCount = ceil(numFrames * (sampleRate_ / bufferFormat_.sampleRate));
+
+    for (size_t i = 0; i < bufferFormat_.channelCount; ++i) {
+      memcpy(
+          converterInputBuffer_.mutableAudioBufferList->mBuffers[i].mData,
+          inputBuffer->mBuffers[i].mData,
+          inputBuffer->mBuffers[i].mDataByteSize);
+    }
+
+    converterInputBuffer_.frameLength = numFrames;
+
+    __block BOOL handedOff = false;
+    AVAudioConverterInputBlock inputBlock =
+        ^AVAudioBuffer *_Nullable(AVAudioPacketCount inNumberOfPackets, AVAudioConverterInputStatus *outStatus)
+    {
+      if (handedOff) {
+        *outStatus = AVAudioConverterInputStatus_NoDataNow;
+        return nil;
+      }
+
+      handedOff = true;
+      *outStatus = AVAudioConverterInputStatus_HaveData;
+      return converterInputBuffer_;
+    };
+
+    [converter_ convertToBuffer:converterOutputBuffer_ error:&error withInputFromBlock:inputBlock];
+    converterOutputBuffer_.frameLength = sampleRate_ / bufferFormat_.sampleRate * numFrames;
+
+    if (error != nil) {
+      invokeOnErrorCallback(
+          std::string("Error during audio conversion, native error: ") + [[error debugDescription] UTF8String]);
+      return;
+    }
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      auto *inputChannel = static_cast<float *>(converterOutputBuffer_.audioBufferList->mBuffers[i].mData);
+      circularBus_[i]->push_back(inputChannel, outputFrameCount);
+    }
+
+    emitAudioData();
+  }
+}
+
+void RecorderCallback::emitAudioData()
+{
+  while (circularBus_[0]->getNumberOfAvailableFrames() >= bufferLength_) {
+    auto bus = std::make_shared<AudioBus>(bufferLength_, channelCount_, sampleRate_);
+
+    for (size_t i = 0; i < channelCount_; ++i) {
+      auto *outputChannel = bus->getChannel(i)->getData();
+      circularBus_[i]->pop_front(outputChannel, bufferLength_);
+    }
+
+    invokeCallback(bus, bufferLength_);
+  }
+}
+
+void RecorderCallback::invokeCallback(const std::shared_ptr<AudioBus> &bus, int numFrames)
+{
+  auto audioBuffer = std::make_shared<AudioBuffer>(bus);
+  auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"buffer", audioBufferHostObject});
+  eventPayload.insert({"numFrames", numFrames});
+
+  if (audioEventHandlerRegistry_) {
+    audioEventHandlerRegistry_->invokeHandlerWithEventBody("audioReady", callbackId_, eventPayload);
+  }
+}
+
+void RecorderCallback::sendRemainingData()
+{
+  auto numberOfFrames = circularBus_[0]->getNumberOfAvailableFrames();
+  auto bus = std::make_shared<AudioBus>(circularBus_[0]->getNumberOfAvailableFrames(), channelCount_, sampleRate_);
+
+  for (size_t i = 0; i < channelCount_; ++i) {
+    auto *outputChannel = bus->getChannel(i)->getData();
+    circularBus_[i]->pop_front(outputChannel, numberOfFrames);
+  }
+
+  invokeCallback(bus, numberOfFrames);
+}
+
+void RecorderCallback::setOnErrorCallback(uint64_t callbackId)
+{
+  errorCallbackId_.store(callbackId);
+}
+
+void RecorderCallback::clearOnErrorCallback()
+{
+  errorCallbackId_.store(0);
+}
+
+void RecorderCallback::invokeOnErrorCallback(const std::string &message)
+{
+  uint64_t callbackId = errorCallbackId_.load();
+
+  // TODO: only the line above is atomic, which means that between reading the callbackId and invoking the callback,
+  // the callback could be cleared. We need to ensure that the callback is still valid when invoking it.
+  // TL;DR: atomic szpont
+  if (audioEventHandlerRegistry_ == nullptr || callbackId == 0) {
+    return;
+  }
+
+  std::unordered_map<std::string, EventValue> eventPayload = {};
+  eventPayload.insert({"message", message});
+  audioEventHandlerRegistry_->invokeHandlerWithEventBody("error", callbackId, eventPayload);
+}
+
+} // namespace audioapi
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.h b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.h
index 72c822e53..73b7a8a7a 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.h
@@ -5,30 +5,26 @@
 
 @class AudioSessionManager;
 
+typedef NS_ENUM(NSInteger, AudioEngineState) {
+  AudioEngineStateIdle = 0,
+  AudioEngineStateRunning,
+  AudioEngineStatePaused,
+  AudioEngineStateInterrupted
+};
+
 @interface AudioEngine : NSObject
 
-@property (nonatomic, assign) bool isInterrupted;
-@property (nonatomic, assign) bool isSupposedToBeRunning;
+@property (nonatomic, assign) AudioEngineState state;
 @property (nonatomic, strong) AVAudioEngine *audioEngine;
 @property (nonatomic, strong) NSMutableDictionary *sourceNodes;
 @property (nonatomic, strong) NSMutableDictionary *sourceFormats;
-@property (nonatomic, strong) NSMutableDictionary *sourceStates;
 @property (nonatomic, strong) AVAudioSinkNode *inputNode;
 @property (nonatomic, weak) AudioSessionManager *sessionManager;
 
-- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager;
-
+- (instancetype)init;
 + (instancetype)sharedInstance;
+
 - (void)cleanup;
-- (bool)rebuildAudioEngineAndStartIfNecessary;
-- (bool)restartAudioEngine;
-- (bool)startEngine;
-- (void)stopEngine;
-- (void)pauseEngine:(NSString *)sourceNodeId;
-- (bool)isRunning;
-- (void)markAsInterrupted;
-- (void)unmarkAsInterrupted;
-- (bool)isSupposedToRun;
 
 - (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format;
 - (void)detachSourceNodeWithId:(NSString *)sourceNodeId;
@@ -36,10 +32,17 @@
 - (void)attachInputNode:(AVAudioSinkNode *)inputNode;
 - (void)detachInputNode;
 
-- (void)logAudioEngineState;
+- (void)onInterruptionBegin;
+- (void)onInterruptionEnd:(bool)shouldResume;
+
+- (AudioEngineState)getState;
 
 - (bool)startIfNecessary;
-- (void)stopIfNecessary;
 - (void)pauseIfNecessary;
+- (void)stopIfNecessary;
+
+- (void)restartAudioEngine;
+
+- (void)logAudioEngineState;
 
 @end
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.mm b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.mm
index b2620139e..2d5d7c0ca 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioEngine.mm
@@ -10,29 +10,25 @@ + (instancetype)sharedInstance
   return _sharedInstance;
 }
 
-- (instancetype)initWithAudioSessionManager:(AudioSessionManager *)sessionManager
+- (instancetype)init
 {
   if (self = [super init]) {
-    self.isInterrupted = false;
-    self.isSupposedToBeRunning = true;
+    self.state = AudioEngineState::AudioEngineStateIdle;
     self.audioEngine = [[AVAudioEngine alloc] init];
     self.inputNode = nil;
 
     self.sourceNodes = [[NSMutableDictionary alloc] init];
     self.sourceFormats = [[NSMutableDictionary alloc] init];
-    self.sourceStates = [[NSMutableDictionary alloc] init];
 
-    self.sessionManager = sessionManager;
+    self.sessionManager = [AudioSessionManager sharedInstance];
   }
 
   _sharedInstance = self;
-
   return self;
 }
 
 - (void)cleanup
 {
-  NSLog(@"[AudioEngine] cleanup");
   if ([self.audioEngine isRunning]) {
     [self.audioEngine stop];
   }
@@ -40,212 +36,182 @@ - (void)cleanup
   self.audioEngine = nil;
   self.sourceNodes = nil;
   self.sourceFormats = nil;
-  self.sourceStates = nil;
   self.inputNode = nil;
 
   [self.sessionManager setActive:false];
   self.sessionManager = nil;
 }
 
-- (void)rebuildAudioEngine
+- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format
 {
-  for (id sourceNodeId in self.sourceNodes) {
-    AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
-    AVAudioFormat *format = [self.sourceFormats valueForKey:sourceNodeId];
-
-    [self.audioEngine attachNode:sourceNode];
-    [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
-  }
-
-  if (self.inputNode) {
-    [self.audioEngine attachNode:self.inputNode];
-    [self.audioEngine connect:self.audioEngine.inputNode to:self.inputNode format:nil];
-  }
-}
+  NSString *sourceNodeId = [[NSUUID UUID] UUIDString];
 
-- (bool)rebuildAudioEngineAndStartIfNecessary
-{
-  [self rebuildAudioEngine];
-  return [self startIfNecessary];
-}
+  [self.sourceNodes setValue:sourceNode forKey:sourceNodeId];
+  [self.sourceFormats setValue:format forKey:sourceNodeId];
 
-- (bool)restartAudioEngine
-{
-  if ([self.audioEngine isRunning]) {
-    [self.audioEngine stop];
-  }
+  [self.audioEngine attachNode:sourceNode];
+  [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
 
-  self.audioEngine = [[AVAudioEngine alloc] init];
-  return [self rebuildAudioEngineAndStartIfNecessary];
+  return sourceNodeId;
 }
 
-- (bool)startEngine
+- (void)detachSourceNodeWithId:(NSString *)sourceNodeId
 {
-  NSLog(@"[AudioEngine] startEngine");
-  NSError *error = nil;
-  self.isSupposedToBeRunning = true;
+  NSLog(@"[AudioEngine] detaching source node with ID: %@", sourceNodeId);
 
-  if ([self.audioEngine isRunning] && ![self isInterrupted]) {
-    NSLog(@"[AudioEngine] Engine is already running");
-    return true;
-  }
+  AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
 
-  if (![self.sessionManager setActive:true]) {
-    return false;
+  if (sourceNode == nil) {
+    NSLog(@"[AudioEngine] No source node found with ID: %@", sourceNodeId);
+    return;
   }
 
-  if ([self isInterrupted]) {
-    NSLog(@"[AudioEngine] rebuilding after interruption");
-    [self.audioEngine stop];
-    [self.audioEngine reset];
-
-    [self rebuildAudioEngine];
-
-    self.isInterrupted = false;
-  }
+  [self.audioEngine detachNode:sourceNode];
 
-  [self.audioEngine prepare];
-  [self.audioEngine startAndReturnError:&error];
+  [self.sourceNodes removeObjectForKey:sourceNodeId];
+  [self.sourceFormats removeObjectForKey:sourceNodeId];
+}
 
-  if (error != nil) {
-    NSLog(@"Error while starting the audio engine: %@", [error debugDescription]);
-    return false;
-  }
+- (void)attachInputNode:(AVAudioSinkNode *)inputNode
+{
+  self.inputNode = inputNode;
 
-  return true;
+  [self.audioEngine attachNode:inputNode];
+  [self.audioEngine connect:self.audioEngine.inputNode to:inputNode format:nil];
 }
 
-- (void)stopEngine
+- (void)detachInputNode
 {
-  NSLog(@"[AudioEngine] stopEngine");
-  if (![self.audioEngine isRunning]) {
+  if (self.inputNode == nil) {
     return;
   }
 
-  self.isSupposedToBeRunning = false;
-  [self.audioEngine stop];
+  [self.audioEngine detachNode:self.inputNode];
+  self.inputNode = nil;
 }
 
-- (void)pauseEngine:(NSString *)sourceNodeId
+- (void)onInterruptionBegin
 {
-  NSLog(@"[AudioEngine] pauseEngine");
-  self.isSupposedToBeRunning = false;
-
-  if (![self.audioEngine isRunning]) {
+  if (self.state != AudioEngineState::AudioEngineStateRunning) {
+    // If engine was not active, do nothing
     return;
   }
 
-  [self.sourceStates setValue:@false forKey:sourceNodeId];
-  [self pauseIfNecessary];
+  // If engine was active or paused (or interrupted :)) mark as interrupted
+  self.state = AudioEngineState::AudioEngineStateInterrupted;
 }
 
-- (bool)isRunning
+- (void)onInterruptionEnd:(bool)shouldResume
 {
-  return [self.audioEngine isRunning] && !self.isInterrupted;
-}
+  if (self.state != AudioEngineState::AudioEngineStateInterrupted) {
+    return;
+  }
 
-- (void)markAsInterrupted
-{
-  self.isInterrupted = true;
-  self.isSupposedToBeRunning = false;
+  // TODO: try to recover
 }
 
-- (void)unmarkAsInterrupted
+- (AudioEngineState)getState
 {
-  self.isInterrupted = false;
+  return self.state;
 }
 
-- (NSString *)attachSourceNode:(AVAudioSourceNode *)sourceNode format:(AVAudioFormat *)format
+- (void)rebuildAudioEngine
 {
-  NSString *sourceNodeId = [[NSUUID UUID] UUIDString];
-  NSLog(@"[AudioEngine] attaching new source node with ID: %@", sourceNodeId);
-
-  [self.sourceNodes setValue:sourceNode forKey:sourceNodeId];
-  [self.sourceFormats setValue:format forKey:sourceNodeId];
-  [self.sourceStates setValue:@true forKey:sourceNodeId];
+  for (id sourceNodeId in self.sourceNodes) {
+    AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
+    AVAudioFormat *format = [self.sourceFormats valueForKey:sourceNodeId];
 
-  [self.audioEngine attachNode:sourceNode];
-  [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
+    [self.audioEngine attachNode:sourceNode];
+    [self.audioEngine connect:sourceNode to:self.audioEngine.mainMixerNode format:format];
+  }
 
-  return sourceNodeId;
+  if (self.inputNode) {
+    [self.audioEngine attachNode:self.inputNode];
+    [self.audioEngine connect:self.audioEngine.inputNode to:self.inputNode format:nil];
+  }
 }
 
-- (void)detachSourceNodeWithId:(NSString *)sourceNodeId
+- (bool)startEngine
 {
-  NSLog(@"[AudioEngine] detaching source node with ID: %@", sourceNodeId);
+  NSError *error = nil;
 
-  AVAudioSourceNode *sourceNode = [self.sourceNodes valueForKey:sourceNodeId];
+  if ([self.audioEngine isRunning] && self.state == AudioEngineState::AudioEngineStateRunning) {
+    return true;
+  }
 
-  if (sourceNode == nil) {
-    NSLog(@"[AudioEngine] No source node found with ID: %@", sourceNodeId);
-    return;
+  if (![self.sessionManager setActive:true]) {
+    return false;
   }
 
-  [self.audioEngine detachNode:sourceNode];
+  if (self.state == AudioEngineState::AudioEngineStateInterrupted) {
+    NSLog(@"[AudioEngine] rebuilding after interruption");
+    [self.audioEngine stop];
+    [self.audioEngine reset];
+    [self rebuildAudioEngine];
+  }
 
-  [self.sourceNodes removeObjectForKey:sourceNodeId];
-  [self.sourceFormats removeObjectForKey:sourceNodeId];
-  [self.sourceStates removeObjectForKey:sourceNodeId];
-}
+  [self.audioEngine prepare];
+  [self.audioEngine startAndReturnError:&error];
 
-- (void)attachInputNode:(AVAudioSinkNode *)inputNode
-{
-  self.inputNode = inputNode;
+  if (error != nil) {
+    NSLog(@"Error while starting the audio engine: %@", [error debugDescription]);
+    return false;
+  }
 
-  [self.audioEngine attachNode:inputNode];
-  [self.audioEngine connect:self.audioEngine.inputNode to:inputNode format:nil];
+  self.state = AudioEngineState::AudioEngineStateRunning;
+  return true;
 }
 
-- (void)detachInputNode
+- (void)stopEngine
 {
-  if (self.inputNode == nil) {
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
     return;
   }
 
-  [self.audioEngine detachNode:self.inputNode];
-  self.inputNode = nil;
-  [self restartAudioEngine];
+  [self.audioEngine stop];
+  self.state = AudioEngineState::AudioEngineStateIdle;
 }
 
 - (bool)startIfNecessary
 {
-  if ([self isRunning]) {
+  if (self.state == AudioEngineState::AudioEngineStateRunning) {
     return true;
   }
 
-  if ([self.sourceNodes count] > 0 || self.inputNode != nil) {
+  if (([self.sourceNodes count] > 0) || self.inputNode != nil) {
     return [self startEngine];
   }
 
   return false;
 }
 
-- (void)stopIfNecessary
+- (void)pauseIfNecessary
 {
-  if (![self isRunning]) {
+  if (self.state == AudioEngineState::AudioEngineStatePaused) {
     return;
   }
 
-  if ([self.sourceNodes count] == 0 && self.inputNode == nil) {
-    [self stopEngine];
-  }
+  [self.audioEngine pause];
+  self.state = AudioEngineState::AudioEngineStatePaused;
 }
 
-- (void)pauseIfNecessary
+- (void)stopIfNecessary
 {
-  if (![self isRunning]) {
+  if (self.state == AudioEngineState::AudioEngineStateIdle) {
     return;
   }
 
-  for (NSString *sourceId in self.sourceStates) {
-    if ([self.sourceStates[sourceId] boolValue]) {
-      NSLog(@"state %@", self.sourceStates[sourceId]);
-      return;
-    }
+  [self stopEngine];
+}
+
+- (void)restartAudioEngine
+{
+  if ([self.audioEngine isRunning]) {
+    [self.audioEngine stop];
   }
 
-  NSLog(@"[AudioEngine] pauseEngine");
-  [self.audioEngine pause];
+  self.audioEngine = [[AVAudioEngine alloc] init];
+  [self rebuildAudioEngine];
 }
 
 - (void)logAudioEngineState
@@ -284,9 +250,4 @@ - (void)logAudioEngineState
   NSLog(@"=======================================================");
 }
 
-- (bool)isSupposedToRun
-{
-  return self.isSupposedToBeRunning;
-}
-
 @end
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.h b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.h
index 19474ad11..2454d7371 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.h
@@ -8,32 +8,41 @@
 
 @property (nonatomic, weak) AVAudioSession *audioSession;
 
+// State tracking
 @property (nonatomic, assign) bool isActive;
-@property (nonatomic, assign) bool hasDirtySettings;
-@property (nonatomic, assign) AVAudioSessionMode sessionMode;
-@property (nonatomic, assign) AVAudioSessionCategory sessionCategory;
-@property (nonatomic, assign) AVAudioSessionCategoryOptions sessionOptions;
-@property (nonatomic, assign) bool allowHapticsAndSystemSoundsDuringRecording;
 @property (nonatomic, assign) bool shouldManageSession;
 
+// Session configuration options (desired by user)
+@property (nonatomic, assign) AVAudioSessionMode desiredMode;
+@property (nonatomic, assign) AVAudioSessionCategory desiredCategory;
+@property (nonatomic, assign) AVAudioSessionCategoryOptions desiredOptions;
+@property (nonatomic, assign) bool allowHapticsAndSounds;
+
 - (instancetype)init;
++ (instancetype)sharedInstance;
+
 - (void)cleanup;
-- (bool)configureAudioSession;
-- (bool)reconfigureAudioSession;
-- (void)markSettingsAsDirty;
 
-- (NSNumber *)getDevicePreferredSampleRate;
 - (void)setAudioSessionOptions:(NSString *)category
                           mode:(NSString *)mode
                        options:(NSArray *)options
                   allowHaptics:(BOOL)allowHaptics;
+
 - (bool)setActive:(bool)active;
+- (void)markInactive;
 - (void)disableSessionManagement;
 
+- (NSNumber *)getDevicePreferredSampleRate;
+
 - (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (NSString *)requestRecordingPermissions;
+
 - (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
+- (NSString *)checkRecordingPermissions;
 
 - (void)getDevicesInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject;
 - (NSArray<NSDictionary *> *)parseDeviceList:(NSArray<AVAudioSessionPortDescription *> *)devices;
 
+- (bool)isSessionActive;
+
 @end
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.mm b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.mm
index 5c22a1725..19cd093cc 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/AudioSessionManager.mm
@@ -1,135 +1,94 @@
+#import <AVFAudio/AVFAudio.h>
 #import <audioapi/ios/system/AudioSessionManager.h>
 
 @implementation AudioSessionManager
 
+static AudioSessionManager *_sharedInstance = nil;
+
 - (instancetype)init
 {
   if (self = [super init]) {
     self.audioSession = [AVAudioSession sharedInstance];
 
-    self.sessionCategory = AVAudioSessionCategoryPlayback;
-    self.sessionMode = AVAudioSessionModeDefault;
-    self.sessionOptions = 0;
-    self.allowHapticsAndSystemSoundsDuringRecording = false;
-    self.hasDirtySettings = true;
     self.isActive = false;
     self.shouldManageSession = true;
+
+    self.desiredCategory = AVAudioSessionCategoryPlayback;
+    self.desiredMode = AVAudioSessionModeDefault;
+    self.desiredOptions = 0;
+    self.allowHapticsAndSounds = false;
   }
 
+  _sharedInstance = self;
   return self;
 }
 
-- (void)cleanup
++ (instancetype)sharedInstance
 {
-  NSLog(@"[AudioSessionManager] cleanup");
+  return _sharedInstance;
+}
 
+- (void)cleanup
+{
   self.audioSession = nil;
 }
 
-- (NSNumber *)getDevicePreferredSampleRate
+- (bool)areDesiredOptionsSet
 {
-  return [NSNumber numberWithFloat:[self.audioSession sampleRate]];
+  return (
+      self.audioSession.category == self.desiredCategory && self.audioSession.mode == self.desiredMode &&
+      self.audioSession.categoryOptions == self.desiredOptions &&
+      self.audioSession.allowHapticsAndSystemSoundsDuringRecording == self.allowHapticsAndSounds);
 }
 
-- (void)setAudioSessionOptions:(NSString *)category
-                          mode:(NSString *)mode
-                       options:(NSArray *)options
-                  allowHaptics:(BOOL)allowHaptics
+- (bool)configureAudioSession
 {
-  AVAudioSessionCategory sessionCategory = self.sessionCategory;
-  AVAudioSessionMode sessionMode = self.sessionMode;
-  AVAudioSessionCategoryOptions sessionOptions = 0;
-  bool allowHapticsAndSystemSoundsDuringRecording = allowHaptics;
-
-  if ([category isEqualToString:@"record"]) {
-    sessionCategory = AVAudioSessionCategoryRecord;
-  } else if ([category isEqualToString:@"ambient"]) {
-    sessionCategory = AVAudioSessionCategoryAmbient;
-  } else if ([category isEqualToString:@"playback"]) {
-    sessionCategory = AVAudioSessionCategoryPlayback;
-  } else if ([category isEqualToString:@"multiRoute"]) {
-    sessionCategory = AVAudioSessionCategoryMultiRoute;
-  } else if ([category isEqualToString:@"soloAmbient"]) {
-    sessionCategory = AVAudioSessionCategorySoloAmbient;
-  } else if ([category isEqualToString:@"playAndRecord"]) {
-    sessionCategory = AVAudioSessionCategoryPlayAndRecord;
-  }
+  NSError *error = nil;
 
-  if ([mode isEqualToString:@"default"]) {
-    sessionMode = AVAudioSessionModeDefault;
-  } else if ([mode isEqualToString:@"gameChat"]) {
-    sessionMode = AVAudioSessionModeGameChat;
-  } else if ([mode isEqualToString:@"videoChat"]) {
-    sessionMode = AVAudioSessionModeVideoChat;
-  } else if ([mode isEqualToString:@"voiceChat"]) {
-    sessionMode = AVAudioSessionModeVoiceChat;
-  } else if ([mode isEqualToString:@"measurement"]) {
-    sessionMode = AVAudioSessionModeMeasurement;
-  } else if ([mode isEqualToString:@"voicePrompt"]) {
-    sessionMode = AVAudioSessionModeVoicePrompt;
-  } else if ([mode isEqualToString:@"spokenAudio"]) {
-    sessionMode = AVAudioSessionModeSpokenAudio;
-  } else if ([mode isEqualToString:@"moviePlayback"]) {
-    sessionMode = AVAudioSessionModeMoviePlayback;
-  } else if ([mode isEqualToString:@"videoRecording"]) {
-    sessionMode = AVAudioSessionModeVideoRecording;
+  if (!self.shouldManageSession || [self areDesiredOptionsSet]) {
+    return true;
   }
 
-  for (NSString *option in options) {
-    if ([option isEqualToString:@"duckOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionDuckOthers;
-    }
+  [self.audioSession setCategory:self.desiredCategory mode:self.desiredMode options:self.desiredOptions error:&error];
 
-    if ([option isEqualToString:@"allowAirPlay"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionAllowAirPlay;
-    }
-
-    if ([option isEqualToString:@"mixWithOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionMixWithOthers;
-    }
-
-    if ([option isEqualToString:@"allowBluetooth"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionAllowBluetooth;
-    }
-
-    if ([option isEqualToString:@"defaultToSpeaker"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionDefaultToSpeaker;
-    }
+  if (error != nil) {
+    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
+    return false;
+  }
 
-    if ([option isEqualToString:@"allowBluetoothA2DP"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
-    }
+  if (self.audioSession.allowHapticsAndSystemSoundsDuringRecording != self.allowHapticsAndSounds) {
+    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSounds error:&error];
 
-    if ([option isEqualToString:@"overrideMutedMicrophoneInterruption"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
-    }
-
-    if ([option isEqualToString:@"interruptSpokenAudioAndMixWithOthers"]) {
-      sessionOptions |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
+    if (error != nil) {
+      NSLog(@"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@", [error debugDescription]);
+      return false;
     }
   }
 
-  if (self.sessionCategory != sessionCategory) {
-    self.hasDirtySettings = true;
-    self.sessionCategory = sessionCategory;
-  }
-
-  if (self.sessionMode != sessionMode) {
-    self.hasDirtySettings = true;
-    self.sessionMode = sessionMode;
-  }
+  return true;
+}
 
-  if (self.sessionOptions != sessionOptions) {
-    self.hasDirtySettings = true;
-    self.sessionOptions = sessionOptions;
+- (void)setAudioSessionOptions:(NSString *)categoryStr
+                          mode:(NSString *)modeStr
+                       options:(NSArray *)optionsArray
+                  allowHaptics:(BOOL)allowHaptics
+{
+  AVAudioSessionCategory category = [self categoryFromString:categoryStr];
+  AVAudioSessionMode mode = [self modeFromString:modeStr];
+  AVAudioSessionCategoryOptions options = [self optionsFromArray:optionsArray];
+  bool configChanged = false;
+
+  if (category != self.desiredCategory || mode != self.desiredMode || options != self.desiredOptions ||
+      allowHaptics != self.allowHapticsAndSounds) {
+    configChanged = true;
   }
 
-  if (self.allowHapticsAndSystemSoundsDuringRecording != allowHapticsAndSystemSoundsDuringRecording) {
-    self.hasDirtySettings = true;
-    self.allowHapticsAndSystemSoundsDuringRecording = allowHapticsAndSystemSoundsDuringRecording;
-  }
+  self.desiredCategory = category;
+  self.desiredMode = mode;
+  self.desiredOptions = options;
+  self.allowHapticsAndSounds = allowHaptics;
 
-  if (self.isActive) {
+  if (configChanged && self.isActive) {
     [self configureAudioSession];
   }
 }
@@ -139,17 +98,23 @@ - (bool)setActive:(bool)active
   if (!self.shouldManageSession) {
     return true;
   }
-  if (active == self.isActive) {
+
+  NSError *error = nil;
+  bool success = false;
+
+  if (self.isActive == active) {
     return true;
   }
 
   if (active) {
-    [self configureAudioSession];
-  }
+    success = [self configureAudioSession];
 
-  NSError *error = nil;
+    if (!success) {
+      return false;
+    }
+  }
 
-  bool success = [self.audioSession setActive:active error:&error];
+  success = [self.audioSession setActive:active error:&error];
 
   if (success) {
     self.isActive = active;
@@ -164,66 +129,22 @@ - (bool)setActive:(bool)active
   return success;
 }
 
-- (bool)configureAudioSession
-{
-  if (!self.shouldManageSession) {
-    NSLog(@"[AudioSessionManager] Skipping AVAudioSession configuration, shouldManageSession is false");
-    return true;
-  }
-
-  if (![self hasDirtySettings]) {
-    return true;
-  }
-
-  NSLog(
-      @"[AudioSessionManager] configureAudioSession, category: %@, mode: %@, options: %lu, allowHaptics: %@",
-      self.sessionCategory,
-      self.sessionMode,
-      (unsigned long)self.sessionOptions,
-      self.allowHapticsAndSystemSoundsDuringRecording ? @"YES" : @"NO");
-
-  NSError *error = nil;
-
-  [self.audioSession setCategory:self.sessionCategory mode:self.sessionMode options:self.sessionOptions error:&error];
-
-  if (error != nil) {
-    NSLog(@"Error while configuring audio session: %@", [error debugDescription]);
-    return false;
-  }
-
-  if (@available(iOS 13.0, *)) {
-    [self.audioSession setAllowHapticsAndSystemSoundsDuringRecording:self.allowHapticsAndSystemSoundsDuringRecording
-                                                               error:&error];
-
-    if (error != nil) {
-      NSLog(@"Error while setting allowHapticsAndSystemSoundsDuringRecording: %@", [error debugDescription]);
-    }
-  }
-
-  self.hasDirtySettings = false;
-  return true;
-}
-
-- (bool)reconfigureAudioSession
-{
-  self.hasDirtySettings = true;
-  if (self.isActive) {
-    self.isActive = false;
-    return [self setActive:true];
-  }
-  return true;
-}
-
-- (void)markSettingsAsDirty
+- (void)markInactive
 {
-  self.hasDirtySettings = true;
+  // Mark as inactive no matter the state reported by AVAudioSession,
+  // this is used during interruptions to "force" going through configure&activate flow
+  // which is necessary after some of the interruptions (f.e. when the other app re-configures the hardware)
   self.isActive = false;
 }
 
 - (void)disableSessionManagement
 {
   self.shouldManageSession = false;
-  self.hasDirtySettings = false;
+}
+
+- (NSNumber *)getDevicePreferredSampleRate
+{
+  return [NSNumber numberWithFloat:[self.audioSession sampleRate]];
 }
 
 - (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
@@ -237,66 +158,71 @@ - (void)requestRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTP
         nil);
     return;
   }
-  if (@available(iOS 17, *)) {
-    [AVAudioSession.sharedInstance requestRecordPermission:^(BOOL granted) {
-      if (granted) {
-        resolve(@"Granted");
-      } else {
-        resolve(@"Denied");
-      }
+
+  resolve([self requestRecordingPermissions]);
+}
+
+- (NSString *)requestRecordingPermissions
+{
+  id value = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSMicrophoneUsageDescription"];
+
+  if (value == nil) {
+    return @"Denied";
+  }
+
+  __block NSString *result = @"Denied";
+  dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+
+#if TARGET_OS_SIMULATOR
+  [self.audioSession requestRecordPermission:^(BOOL granted) {
+    result = granted ? @"Granted" : @"Denied";
+    dispatch_semaphore_signal(sem);
+  }];
+
+  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  return result;
+#else
+  if (@available(iOS 17.0, *)) {
+    [AVAudioApplication requestRecordPermissionWithCompletionHandler:^(BOOL granted) {
+      result = granted ? @"Granted" : @"Denied";
+      dispatch_semaphore_signal(sem);
     }];
   } else {
     [self.audioSession requestRecordPermission:^(BOOL granted) {
-      if (granted) {
-        resolve(@"Granted");
-      } else {
-        resolve(@"Denied");
-      }
+      result = granted ? @"Granted" : @"Denied";
+      dispatch_semaphore_signal(sem);
     }];
   }
+
+  dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  return result;
+#endif
 }
 
 - (void)checkRecordingPermissions:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  if (@available(iOS 17, *)) {
-    NSInteger res = [[AVAudioApplication sharedInstance] recordPermission];
-    switch (res) {
-      case AVAudioApplicationRecordPermissionUndetermined:
-        resolve(@"Undetermined");
-        break;
-      case AVAudioApplicationRecordPermissionGranted:
-        resolve(@"Granted");
-        break;
-      case AVAudioApplicationRecordPermissionDenied:
-        resolve(@"Denied");
-        break;
-      default:
-        resolve(@"Undetermined");
-        break;
-    }
-  } else {
-    NSInteger res = [self.audioSession recordPermission];
-    switch (res) {
-      case AVAudioSessionRecordPermissionUndetermined:
-        resolve(@"Undetermined");
-        break;
-      case AVAudioSessionRecordPermissionGranted:
-        resolve(@"Granted");
-        break;
-      case AVAudioSessionRecordPermissionDenied:
-        resolve(@"Denied");
-        break;
-      default:
-        resolve(@"Undetermined");
-        break;
-    }
-  }
+  resolve([self checkRecordingPermissions]);
 }
 
 - (NSString *)checkRecordingPermissions
 {
+#if TARGET_OS_SIMULATOR
+  NSInteger res = [self.audioSession recordPermission];
+
+  switch (res) {
+    case AVAudioSessionRecordPermissionUndetermined:
+      return @"Undetermined";
+    case AVAudioSessionRecordPermissionGranted:
+      return @"Granted";
+    case AVAudioSessionRecordPermissionDenied:
+      return @"Denied";
+    default:
+      return @"Undetermined";
+  }
+#else
   if (@available(iOS 17, *)) {
     NSInteger res = [[AVAudioApplication sharedInstance] recordPermission];
+
     switch (res) {
       case AVAudioApplicationRecordPermissionUndetermined:
         return @"Undetermined";
@@ -307,19 +233,21 @@ - (NSString *)checkRecordingPermissions
       default:
         return @"Undetermined";
     }
-  } else {
-    NSInteger res = [self.audioSession recordPermission];
-    switch (res) {
-      case AVAudioSessionRecordPermissionUndetermined:
-        return @"Undetermined";
-      case AVAudioSessionRecordPermissionGranted:
-        return @"Granted";
-      case AVAudioSessionRecordPermissionDenied:
-        return @"Denied";
-      default:
-        return @"Undetermined";
-    }
   }
+
+  NSInteger res = [self.audioSession recordPermission];
+
+  switch (res) {
+    case AVAudioSessionRecordPermissionUndetermined:
+      return @"Undetermined";
+    case AVAudioSessionRecordPermissionGranted:
+      return @"Granted";
+    case AVAudioSessionRecordPermissionDenied:
+      return @"Denied";
+    default:
+      return @"Undetermined";
+  }
+#endif
 }
 
 - (void)getDevicesInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
@@ -348,4 +276,98 @@ - (void)getDevicesInfo:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectB
   return deviceList;
 }
 
+- (AVAudioSessionCategory)categoryFromString:(NSString *)categorySTR
+{
+  AVAudioSessionCategory category = 0;
+
+  if ([categorySTR isEqualToString:@"record"]) {
+    category = AVAudioSessionCategoryRecord;
+  } else if ([categorySTR isEqualToString:@"ambient"]) {
+    category = AVAudioSessionCategoryAmbient;
+  } else if ([categorySTR isEqualToString:@"playback"]) {
+    category = AVAudioSessionCategoryPlayback;
+  } else if ([categorySTR isEqualToString:@"multiRoute"]) {
+    category = AVAudioSessionCategoryMultiRoute;
+  } else if ([categorySTR isEqualToString:@"soloAmbient"]) {
+    category = AVAudioSessionCategorySoloAmbient;
+  } else if ([categorySTR isEqualToString:@"playAndRecord"]) {
+    category = AVAudioSessionCategoryPlayAndRecord;
+  }
+
+  return category;
+}
+
+- (AVAudioSessionMode)modeFromString:(NSString *)modeSTR
+{
+  AVAudioSessionMode mode = 0;
+
+  if ([modeSTR isEqualToString:@"default"]) {
+    mode = AVAudioSessionModeDefault;
+  } else if ([modeSTR isEqualToString:@"gameChat"]) {
+    mode = AVAudioSessionModeGameChat;
+  } else if ([modeSTR isEqualToString:@"videoChat"]) {
+    mode = AVAudioSessionModeVideoChat;
+  } else if ([modeSTR isEqualToString:@"voiceChat"]) {
+    mode = AVAudioSessionModeVoiceChat;
+  } else if ([modeSTR isEqualToString:@"measurement"]) {
+    mode = AVAudioSessionModeMeasurement;
+  } else if ([modeSTR isEqualToString:@"voicePrompt"]) {
+    mode = AVAudioSessionModeVoicePrompt;
+  } else if ([modeSTR isEqualToString:@"spokenAudio"]) {
+    mode = AVAudioSessionModeSpokenAudio;
+  } else if ([modeSTR isEqualToString:@"moviePlayback"]) {
+    mode = AVAudioSessionModeMoviePlayback;
+  } else if ([modeSTR isEqualToString:@"videoRecording"]) {
+    mode = AVAudioSessionModeVideoRecording;
+  }
+
+  return mode;
+}
+
+- (AVAudioSessionCategoryOptions)optionsFromArray:(NSArray *)optionsArray
+{
+  AVAudioSessionCategoryOptions options = 0;
+
+  for (NSString *option in optionsArray) {
+    if ([option isEqualToString:@"duckOthers"]) {
+      options |= AVAudioSessionCategoryOptionDuckOthers;
+    }
+
+    if ([option isEqualToString:@"allowAirPlay"]) {
+      options |= AVAudioSessionCategoryOptionAllowAirPlay;
+    }
+
+    if ([option isEqualToString:@"mixWithOthers"]) {
+      options |= AVAudioSessionCategoryOptionMixWithOthers;
+    }
+
+    if ([option isEqualToString:@"allowBluetooth"]) {
+      options |= AVAudioSessionCategoryOptionAllowBluetooth;
+    }
+
+    if ([option isEqualToString:@"defaultToSpeaker"]) {
+      options |= AVAudioSessionCategoryOptionDefaultToSpeaker;
+    }
+
+    if ([option isEqualToString:@"allowBluetoothA2DP"]) {
+      options |= AVAudioSessionCategoryOptionAllowBluetoothA2DP;
+    }
+
+    if ([option isEqualToString:@"overrideMutedMicrophoneInterruption"]) {
+      options |= AVAudioSessionCategoryOptionOverrideMutedMicrophoneInterruption;
+    }
+
+    if ([option isEqualToString:@"interruptSpokenAudioAndMixWithOthers"]) {
+      options |= AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers;
+    }
+  }
+
+  return options;
+}
+
+- (bool)isSessionActive
+{
+  return self.isActive;
+}
+
 @end
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.h b/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.h
index 09a66b08f..48e853a40 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.h
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.h
@@ -12,6 +12,7 @@
 
 @property (nonatomic, weak) MPNowPlayingInfoCenter *playingInfoCenter;
 @property (nonatomic, copy) NSString *artworkUrl;
+@property (nonatomic, assign) bool isReceivingRemoteCommands;
 
 - (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule;
 - (void)cleanup;
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.mm b/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.mm
index 26fc5adea..988d4d055 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/LockScreenManager.mm
@@ -19,28 +19,40 @@ - (instancetype)initWithAudioAPIModule:(AudioAPIModule *)audioAPIModule
   if (self = [super init]) {
     self.audioAPIModule = audioAPIModule;
     self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+    self.isReceivingRemoteCommands = false;
+  }
+
+  return self;
+}
 
+- (void)toggleRemoteCommands:(bool)enable
+{
+  if (enable && !self.isReceivingRemoteCommands) {
+    self.isReceivingRemoteCommands = true;
     dispatch_async(dispatch_get_main_queue(), ^{
       [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
     });
+    return;
+  } else if (!enable && self.isReceivingRemoteCommands) {
+    self.isReceivingRemoteCommands = false;
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
+    });
+    return;
   }
-
-  return self;
 }
 
 - (void)cleanup
 {
   NSLog(@"[LockScreenManager] cleanup");
+  [self toggleRemoteCommands:false];
   [self resetLockScreenInfo];
-
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
-  });
 }
 
 - (void)setLockScreenInfo:(NSDictionary *)info
 {
   self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
+  [self toggleRemoteCommands:true];
 
   // now playing info(lock screen info)
   NSMutableDictionary *lockScreenInfoDict;
@@ -79,6 +91,7 @@ - (void)setLockScreenInfo:(NSDictionary *)info
 
 - (void)resetLockScreenInfo
 {
+  [self toggleRemoteCommands:false];
   self.playingInfoCenter = [MPNowPlayingInfoCenter defaultCenter];
   self.playingInfoCenter.nowPlayingInfo = nil;
   self.artworkUrl = nil;
diff --git a/packages/react-native-audio-api/ios/audioapi/ios/system/NotificationManager.mm b/packages/react-native-audio-api/ios/audioapi/ios/system/NotificationManager.mm
index 6e8b9a14b..10554a3ca 100644
--- a/packages/react-native-audio-api/ios/audioapi/ios/system/NotificationManager.mm
+++ b/packages/react-native-audio-api/ios/audioapi/ios/system/NotificationManager.mm
@@ -110,11 +110,14 @@ - (void)observeValueForKeyPath:(NSString *)keyPath
 - (void)handleInterruption:(NSNotification *)notification
 {
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
+  AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
+
   NSInteger interruptionType = [notification.userInfo[AVAudioSessionInterruptionTypeKey] integerValue];
   NSInteger interruptionOption = [notification.userInfo[AVAudioSessionInterruptionOptionKey] integerValue];
 
   if (interruptionType == AVAudioSessionInterruptionTypeBegan) {
-    [audioEngine markAsInterrupted];
+    [audioEngine onInterruptionBegin];
+    [sessionManager markInactive];
 
     if (self.audioInterruptionsObserved) {
       NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
@@ -124,54 +127,38 @@ - (void)handleInterruption:(NSNotification *)notification
     return;
   }
 
-  if (interruptionOption == AVAudioSessionInterruptionOptionShouldResume) {
-    [audioEngine unmarkAsInterrupted];
-
-    if (self.audioInterruptionsObserved) {
-      NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
-    }
-
-    return;
-  }
+  bool shouldResume = interruptionOption == AVAudioSessionInterruptionOptionShouldResume;
+  [audioEngine onInterruptionEnd:shouldResume];
 
   if (self.audioInterruptionsObserved) {
-    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @false};
+    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
   }
 }
 
 - (void)handleSecondaryAudio:(NSNotification *)notification
 {
+  NSLog(@"handleSecondaryAudio");
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
+  AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
   NSInteger secondaryAudioType = [notification.userInfo[AVAudioSessionSilenceSecondaryAudioHintTypeKey] integerValue];
 
-  NSLog(@"handleSecondaryAudio");
-
   if (secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeBegin) {
-    [audioEngine markAsInterrupted];
+    [sessionManager markInactive];
+    [audioEngine onInterruptionBegin];
 
     if (self.audioInterruptionsObserved) {
       NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
       [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
     }
-
     return;
   }
 
-  if (secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeEnd) {
-    [audioEngine unmarkAsInterrupted];
-
-    if (self.audioInterruptionsObserved) {
-      NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
-      [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
-    }
-
-    return;
-  }
+  bool shouldResume = secondaryAudioType == AVAudioSessionSilenceSecondaryAudioHintTypeEnd;
+  [audioEngine onInterruptionEnd:shouldResume];
 
   if (self.audioInterruptionsObserved) {
-    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @false};
+    NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @(shouldResume)};
     [self.audioAPIModule invokeHandlerWithEventName:@"interruption" eventBody:body];
   }
 }
@@ -220,10 +207,10 @@ - (void)handleMediaServicesReset:(NSNotification *)notification
 {
   NSLog(@"[NotificationManager] Media services have been reset, tearing down and rebuilding everything.");
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
-  AudioSessionManager *audioSessionManager = self.audioAPIModule.audioSessionManager;
 
-  [audioSessionManager reconfigureAudioSession];
-  [audioEngine restartAudioEngine];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [audioEngine restartAudioEngine];
+  });
 }
 
 - (void)handleEngineConfigurationChange:(NSNotification *)notification
@@ -231,15 +218,9 @@ - (void)handleEngineConfigurationChange:(NSNotification *)notification
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
   AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
 
-  if (![audioEngine isSupposedToBeRunning]) {
-    NSLog(@"[NotificationManager] detected engine configuration change when engine is not running");
-    [sessionManager markSettingsAsDirty];
-    return;
-  }
-
   dispatch_async(dispatch_get_main_queue(), ^{
-    [sessionManager markSettingsAsDirty];
-    [audioEngine rebuildAudioEngineAndStartIfNecessary];
+    [sessionManager markInactive];
+    [audioEngine restartAudioEngine];
   });
 }
 
@@ -275,10 +256,13 @@ - (void)checkSecondaryAudioHint
   }
 
   AudioEngine *audioEngine = self.audioAPIModule.audioEngine;
+  AudioSessionManager *sessionManager = self.audioAPIModule.audioSessionManager;
+
   self.wasOtherAudioPlaying = shouldSilence;
 
   if (shouldSilence) {
-    [audioEngine markAsInterrupted];
+    [sessionManager markInactive];
+    [audioEngine onInterruptionBegin];
     NSDictionary *body = @{@"type" : @"began", @"shouldResume" : @false};
 
     if (self.audioInterruptionsObserved) {
@@ -288,7 +272,7 @@ - (void)checkSecondaryAudioHint
     return;
   }
 
-  [audioEngine unmarkAsInterrupted];
+  [audioEngine onInterruptionEnd:true];
   NSDictionary *body = @{@"type" : @"ended", @"shouldResume" : @true};
 
   if (self.audioInterruptionsObserved) {
diff --git a/packages/react-native-audio-api/package.json b/packages/react-native-audio-api/package.json
index 7befb2d16..ed0a3166a 100644
--- a/packages/react-native-audio-api/package.json
+++ b/packages/react-native-audio-api/package.json
@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.11.0",
+  "version": "0.11.0-alpha.1",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"
@@ -96,7 +96,7 @@
     "@babel/core": "^7.25.2",
     "@babel/preset-env": "^7.25.3",
     "@babel/types": "^7.20.0",
-    "@commitlint/config-conventional": "^17.0.2",
+    "@commitlint/config-conventional": "17.0.2",
     "@evilmartians/lefthook": "^1.5.0",
     "@expo/config-plugins": "^9.0.0",
     "@expo/config-types": "^53.0.4",
@@ -114,7 +114,7 @@
     "@types/react-test-renderer": "^19.1.0",
     "@types/semver": "7.7.1",
     "babel-plugin-module-resolver": "^4.1.0",
-    "commitlint": "^17.0.2",
+    "commitlint": "17.0.2",
     "del-cli": "^5.1.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^8.3.0",
@@ -136,7 +136,7 @@
     "react-native": "0.82.0",
     "react-native-builder-bob": "0.33.1",
     "turbo": "^1.10.7",
-    "typescript": "5.8.3"
+    "typescript": "~5.8.3"
   },
   "react-native-builder-bob": {
     "source": "src",
diff --git a/packages/react-native-audio-api/src/api.ts b/packages/react-native-audio-api/src/api.ts
index 21586a4f2..4d28745d6 100644
--- a/packages/react-native-audio-api/src/api.ts
+++ b/packages/react-native-audio-api/src/api.ts
@@ -1,13 +1,12 @@
-import { NativeAudioAPIModule } from './specs';
-import { AudioRecorderOptions } from './types';
 import type {
   IAudioContext,
   IAudioDecoder,
+  IAudioEventEmitter,
   IAudioRecorder,
   IAudioStretcher,
   IOfflineAudioContext,
-  IAudioEventEmitter,
 } from './interfaces';
+import { NativeAudioAPIModule } from './specs';
 
 /* eslint-disable no-var */
 declare global {
@@ -25,7 +24,7 @@ declare global {
     audioWorkletRuntime: any
   ) => IOfflineAudioContext;
 
-  var createAudioRecorder: (options: AudioRecorderOptions) => IAudioRecorder;
+  var createAudioRecorder: () => IAudioRecorder;
 
   var createAudioDecoder: () => IAudioDecoder;
 
@@ -52,59 +51,35 @@ if (
   NativeAudioAPIModule.install();
 }
 
-export { default as WorkletNode } from './core/WorkletNode';
-export { default as WorkletSourceNode } from './core/WorkletSourceNode';
-export { default as WorkletProcessingNode } from './core/WorkletProcessingNode';
-export { default as RecorderAdapterNode } from './core/RecorderAdapterNode';
+export { default as AnalyserNode } from './core/AnalyserNode';
 export { default as AudioBuffer } from './core/AudioBuffer';
-export { default as AudioBufferSourceNode } from './core/AudioBufferSourceNode';
 export { default as AudioBufferQueueSourceNode } from './core/AudioBufferQueueSourceNode';
+export { default as AudioBufferSourceNode } from './core/AudioBufferSourceNode';
 export { default as AudioContext } from './core/AudioContext';
-export { default as OfflineAudioContext } from './core/OfflineAudioContext';
+export { decodeAudioData, decodePCMInBase64 } from './core/AudioDecoder';
 export { default as AudioDestinationNode } from './core/AudioDestinationNode';
 export { default as AudioNode } from './core/AudioNode';
-export { default as AnalyserNode } from './core/AnalyserNode';
 export { default as AudioParam } from './core/AudioParam';
+export { default as AudioRecorder } from './core/AudioRecorder';
 export { default as AudioScheduledSourceNode } from './core/AudioScheduledSourceNode';
+export { default as changePlaybackSpeed } from './core/AudioStretcher';
 export { default as BaseAudioContext } from './core/BaseAudioContext';
 export { default as BiquadFilterNode } from './core/BiquadFilterNode';
+export { default as ConstantSourceNode } from './core/ConstantSourceNode';
+export { default as ConvolverNode } from './core/ConvolverNode';
 export { default as GainNode } from './core/GainNode';
+export { default as OfflineAudioContext } from './core/OfflineAudioContext';
 export { default as OscillatorNode } from './core/OscillatorNode';
+export { default as RecorderAdapterNode } from './core/RecorderAdapterNode';
 export { default as StereoPannerNode } from './core/StereoPannerNode';
-export { default as AudioRecorder } from './core/AudioRecorder';
 export { default as StreamerNode } from './core/StreamerNode';
-export { default as ConstantSourceNode } from './core/ConstantSourceNode';
-export { default as AudioManager } from './system';
-export { default as ConvolverNode } from './core/ConvolverNode';
-export { default as useSystemVolume } from './hooks/useSystemVolume';
-export { decodeAudioData, decodePCMInBase64 } from './core/AudioDecoder';
-export { default as changePlaybackSpeed } from './core/AudioStretcher';
-
-export {
-  OscillatorType,
-  BiquadFilterType,
-  ChannelCountMode,
-  ChannelInterpretation,
-  ContextState,
-  WindowType,
-  PeriodicWaveConstraints,
-  AudioWorkletRuntime,
-} from './types';
+export { default as WorkletNode } from './core/WorkletNode';
+export { default as WorkletProcessingNode } from './core/WorkletProcessingNode';
+export { default as WorkletSourceNode } from './core/WorkletSourceNode';
 
-export {
-  IOSCategory,
-  IOSMode,
-  IOSOption,
-  SessionOptions,
-  MediaState,
-  LockScreenInfo,
-  PermissionStatus,
-} from './system/types';
+export { default as useSystemVolume } from './hooks/useSystemVolume';
+export { default as AudioManager } from './system';
 
-export {
-  IndexSizeError,
-  InvalidAccessError,
-  InvalidStateError,
-  RangeError,
-  NotSupportedError,
-} from './errors';
+export * from './errors';
+export * from './system/types';
+export * from './types';
diff --git a/packages/react-native-audio-api/src/core/AudioRecorder.ts b/packages/react-native-audio-api/src/core/AudioRecorder.ts
index 77eedc389..ee8b89bbb 100644
--- a/packages/react-native-audio-api/src/core/AudioRecorder.ts
+++ b/packages/react-native-audio-api/src/core/AudioRecorder.ts
@@ -1,57 +1,225 @@
-import { IAudioRecorder } from '../interfaces';
-import { AudioRecorderOptions } from '../types';
+import { AudioEventEmitter, AudioEventSubscription } from '../events';
+import {
+  OnAudioReadyEventType,
+  OnRecorderErrorEventType,
+} from '../events/types';
+import { IAudioRecorder, IAudioRecorderFileOptions } from '../interfaces';
+import {
+  AudioRecorderCallbackOptions,
+  AudioRecorderFileOptions,
+  FileDirectory,
+  FileFormat,
+  FileInfo,
+  Result,
+} from '../types';
+import FilePreset from '../utils/filePresets';
 import AudioBuffer from './AudioBuffer';
-import { OnAudioReadyEventType } from '../events/types';
-import { AudioEventEmitter } from '../events';
 import RecorderAdapterNode from './RecorderAdapterNode';
 
+function withDefaultOptions(
+  inOptions: AudioRecorderFileOptions
+): IAudioRecorderFileOptions {
+  return {
+    directory: FileDirectory.Cache,
+    subDirectory: 'AudioAPI',
+    fileNamePrefix: 'recording_',
+    channelCount: 2,
+    format: FileFormat.M4A,
+    batchDurationSeconds: 0,
+    preset: FilePreset.High,
+    ...inOptions,
+  };
+}
+
 export default class AudioRecorder {
+  protected onAudioReadySubscription: AudioEventSubscription | null = null;
+  protected onErrorSubscription: AudioEventSubscription | null = null;
   protected readonly recorder: IAudioRecorder;
+  protected options_: AudioRecorderFileOptions | null = null;
+  private isFileOutputEnabled: boolean = false;
 
-  private readonly audioEventEmitter = new AudioEventEmitter(
+  protected readonly audioEventEmitter = new AudioEventEmitter(
     global.AudioEventEmitter
   );
 
-  constructor(options: AudioRecorderOptions) {
-    this.recorder = global.createAudioRecorder(options);
+  constructor() {
+    this.recorder = global.createAudioRecorder();
+  }
+
+  enableFileOutput(
+    options: AudioRecorderFileOptions
+  ): Result<{ path: string }> {
+    this.options_ = options;
+    const parsedOptions = withDefaultOptions(options);
+    const result = this.recorder.enableFileOutput(parsedOptions);
+    this.isFileOutputEnabled = true;
+
+    return result;
   }
 
-  public start(): void {
-    this.recorder.start();
+  public get options(): AudioRecorderFileOptions | null {
+    return this.options_;
   }
 
-  public stop(): void {
-    this.recorder.stop();
+  disableFileOutput(): void {
+    this.options_ = null;
+    this.recorder.disableFileOutput();
+    this.isFileOutputEnabled = false;
   }
 
-  public connect(node: RecorderAdapterNode): void {
+  /** Starts the audio recording process with configured output options */
+  start(): Result<{ path: string }> {
+    if (!this.isFileOutputEnabled) {
+      this.recorder.start();
+      return { status: 'success', path: '' };
+    }
+
+    return this.recorder.start();
+  }
+
+  /** Stops the audio recording process and releases internal resources */
+  stop(): Result<FileInfo> {
+    return this.recorder.stop();
+  }
+
+  /** Pauses the audio recording process without tearing down anything */
+  pause(): void {
+    this.recorder.pause();
+  }
+
+  /** Resumes the audio recording process after being paused */
+  resume(): void {
+    this.recorder.resume();
+  }
+
+  /**
+   * Connects a {@link RecorderAdapterNode} to the recorder’s audio graph.
+   *
+   * Each node can only be connected once. Attempting to connect a node multiple
+   * times will throw an error.
+   *
+   * @param node - The adapter node to connect to the recorder.
+   * @throws If the node has already been connected.
+   */
+  connect(node: RecorderAdapterNode): void {
     if (node.wasConnected) {
       throw new Error(
         'RecorderAdapterNode cannot be connected more than once. Refer to the documentation for more details.'
       );
     }
+
     node.wasConnected = true;
     this.recorder.connect(node.getNode());
   }
 
-  public disconnect(): void {
+  /**
+   * Disconnects the recorder from all connected adapter nodes.
+   *
+   * After calling this method, any connected {@link RecorderAdapterNode} will no
+   * longer receive audio data until reconnected.
+   */
+  disconnect(): void {
     this.recorder.disconnect();
   }
 
-  public onAudioReady(callback: (event: OnAudioReadyEventType) => void): void {
-    const onAudioReadyCallback = (event: OnAudioReadyEventType) => {
-      callback({
-        buffer: new AudioBuffer(event.buffer),
-        numFrames: event.numFrames,
-        when: event.when,
+  /**
+   * Registers a callback to receive raw audio data during an active recording
+   * session.
+   *
+   * The callback is periodically invoked with audio buffers that match the
+   * preferred configuration provided in `options`. These parameters (sample
+   * rate, buffer length, and channel count) guide how audio data is chunked and
+   * delivered, though the exact values may vary depending on device
+   * capabilities. Values may vary depending on device capabilities.
+   *
+   * @param options - Preferred configuration for the audio buffers delivered to
+   *   the callback.
+   * @param callback - Function invoked each time a new audio buffer is
+   *   available. The callback receives an {@link OnAudioReadyEventType} object
+   *   containing the audio data and associated metadata.
+   */
+  onAudioReady(
+    options: AudioRecorderCallbackOptions,
+    callback: (event: OnAudioReadyEventType) => void
+  ): Result<void> {
+    if (this.onAudioReadySubscription) {
+      this.recorder.clearOnAudioReady();
+      this.onAudioReadySubscription.remove();
+      this.onAudioReadySubscription = null;
+    }
+
+    this.onAudioReadySubscription =
+      this.audioEventEmitter.addAudioEventListener('audioReady', (event) => {
+        const audioBuffer = new AudioBuffer(event.buffer);
+        callback({
+          ...event,
+          buffer: audioBuffer,
+        });
       });
-    };
 
-    const subscription = this.audioEventEmitter.addAudioEventListener(
-      'audioReady',
-      onAudioReadyCallback
+    return this.recorder.setOnAudioReady({
+      sampleRate: options.sampleRate,
+      bufferLength: options.bufferLength,
+      channelCount: options.channelCount,
+      callbackId: this.onAudioReadySubscription.subscriptionId,
+    });
+  }
+
+  /**
+   * Removes the previously registered audio data callback, if any.
+   *
+   * This stops further `onAudioReady` events from being delivered during
+   * recording. Calling this method is safe even if no callback is currently
+   * registered.
+   */
+  clearOnAudioReady(): void {
+    if (!this.onAudioReadySubscription) {
+      return;
+    }
+
+    this.recorder.clearOnAudioReady();
+
+    this.onAudioReadySubscription.remove();
+    this.onAudioReadySubscription = null;
+  }
+
+  isRecording(): boolean {
+    return this.recorder.isRecording();
+  }
+
+  isPaused(): boolean {
+    return this.recorder.isPaused();
+  }
+
+  getCurrentDuration(): number {
+    return this.recorder.getCurrentDuration();
+  }
+
+  onError(callback: (error: OnRecorderErrorEventType) => void): void {
+    if (this.onErrorSubscription) {
+      this.recorder.clearOnError();
+      this.onErrorSubscription.remove();
+      this.onErrorSubscription = null;
+    }
+
+    this.onErrorSubscription = this.audioEventEmitter.addAudioEventListener(
+      'recorderError',
+      callback
     );
 
-    this.recorder.onAudioReady = subscription.subscriptionId;
+    this.recorder.setOnError({
+      callbackId: this.onErrorSubscription.subscriptionId,
+    });
+  }
+
+  clearOnError(): void {
+    if (!this.onErrorSubscription) {
+      return;
+    }
+
+    this.recorder.clearOnError();
+
+    this.onErrorSubscription.remove();
+    this.onErrorSubscription = null;
   }
 }
diff --git a/packages/react-native-audio-api/src/events/types.ts b/packages/react-native-audio-api/src/events/types.ts
index 93556c61f..d9f02416e 100644
--- a/packages/react-native-audio-api/src/events/types.ts
+++ b/packages/react-native-audio-api/src/events/types.ts
@@ -23,6 +23,11 @@ interface OnRouteChangeEventType {
     | 'NoSuitableRouteForCategory';
 }
 
+export interface OnRecorderErrorEventType {
+  type: 'todo';
+  message: string;
+}
+
 interface RemoteCommandEvents {
   remotePlay: EventEmptyType;
   remotePause: EventEmptyType;
@@ -49,9 +54,27 @@ export interface OnEndedEventType extends EventEmptyType {
   isLast: boolean | undefined;
 }
 
+/**
+ * Represents the data payload received by the audio recorder callback each time
+ * a new audio buffer becomes available during recording.
+ */
 export interface OnAudioReadyEventType {
+  /**
+   * The audio buffer containing the recorded PCM data. This buffer includes one
+   * or more channels of floating-point samples in the range of -1.0 to 1.0.
+   */
   buffer: AudioBuffer;
+
+  /**
+   * The number of audio frames contained in this buffer. A frame represents a
+   * single sample across all channels.
+   */
   numFrames: number;
+
+  /**
+   * The timestamp (in seconds) indicating when this buffer was captured,
+   * relative to the start of the recording session.
+   */
   when: number;
 }
 
@@ -62,6 +85,7 @@ interface AudioAPIEvents {
   positionChanged: EventTypeWithValue;
   audioError: EventEmptyType; // to change
   systemStateChanged: EventEmptyType; // to change
+  recorderError: OnRecorderErrorEventType;
 }
 
 type AudioEvents = SystemEvents & AudioAPIEvents;
diff --git a/packages/react-native-audio-api/src/index.ts b/packages/react-native-audio-api/src/index.ts
index b1c13e734..1aefd2f2a 100644
--- a/packages/react-native-audio-api/src/index.ts
+++ b/packages/react-native-audio-api/src/index.ts
@@ -1 +1,3 @@
 export * from './api';
+
+export { default as FilePreset } from './utils/filePresets';
diff --git a/packages/react-native-audio-api/src/interfaces.ts b/packages/react-native-audio-api/src/interfaces.ts
index 0b78cc8b0..a92580538 100644
--- a/packages/react-native-audio-api/src/interfaces.ts
+++ b/packages/react-native-audio-api/src/interfaces.ts
@@ -1,10 +1,17 @@
 import { AudioEventCallback, AudioEventName } from './events/types';
-import {
+import type {
   BiquadFilterType,
+  BitDepth,
   ChannelCountMode,
   ChannelInterpretation,
   ContextState,
+  FileDirectory,
+  FileFormat,
+  FileInfo,
+  FlacCompressionLevel,
+  IOSAudioQuality,
   OscillatorType,
+  Result,
   WindowType,
 } from './types';
 
@@ -261,14 +268,61 @@ export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
 
 export interface IWorkletProcessingNode extends IAudioNode {}
 
+export interface IFilePreset {
+  sampleRate: number;
+  bitRate: number;
+  bitDepth: BitDepth;
+  iosQuality: IOSAudioQuality;
+  flacCompressionLevel: FlacCompressionLevel;
+}
+
+export interface IAudioRecorderFileOptions {
+  channelCount: number;
+  batchDurationSeconds: number;
+
+  format: FileFormat;
+  preset: IFilePreset;
+
+  directory: FileDirectory;
+  subDirectory: string;
+  fileNamePrefix: string;
+}
+
+export interface IAudioRecorderCallbackOptions {
+  sampleRate: number;
+  bufferLength: number;
+  channelCount: number;
+  callbackId: string;
+}
+
 export interface IAudioRecorder {
-  start: () => void;
-  stop: () => void;
+  // default recorder methods
+  start: () => Result<{ path: string }>;
+  stop: () => Result<FileInfo>;
+  isRecording: () => boolean;
+  isPaused: () => boolean;
+
+  enableFileOutput: (
+    options: IAudioRecorderFileOptions
+  ) => Result<{ path: string }>;
+  disableFileOutput: () => void;
+
+  // pause and resume methods for file recording
+  pause: () => void;
+  resume: () => void;
+
+  // Graph integration methods
   connect: (node: IRecorderAdapterNode) => void;
   disconnect: () => void;
 
-  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
-  onAudioReady: string;
+  setOnAudioReady: (options: IAudioRecorderCallbackOptions) => Result<void>;
+  clearOnAudioReady: () => void;
+
+  setOnError: (options: { callbackId: string }) => void;
+  clearOnError: () => void;
+
+  getCurrentDuration: () => number;
+  getFilePath: () => string | null;
 }
 
 export interface IAudioDecoder {
diff --git a/packages/react-native-audio-api/src/specs/NativeAudioAPIModule.ts b/packages/react-native-audio-api/src/specs/NativeAudioAPIModule.ts
index 21fa17a88..d377436fa 100644
--- a/packages/react-native-audio-api/src/specs/NativeAudioAPIModule.ts
+++ b/packages/react-native-audio-api/src/specs/NativeAudioAPIModule.ts
@@ -1,7 +1,7 @@
 'use strict';
-import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native';
-import { PermissionStatus, AudioDevicesInfo } from '../system/types';
+import { TurboModuleRegistry } from 'react-native';
+import { AudioDevicesInfo, PermissionStatus } from '../system/types';
 
 interface Spec extends TurboModule {
   install(): boolean;
diff --git a/packages/react-native-audio-api/src/types.ts b/packages/react-native-audio-api/src/types.ts
index 61fb3e0cf..50900728b 100644
--- a/packages/react-native-audio-api/src/types.ts
+++ b/packages/react-native-audio-api/src/types.ts
@@ -1,5 +1,9 @@
 import AudioBuffer from './core/AudioBuffer';
 
+export type Result<T> =
+  | ({ status: 'success' } & T)
+  | { status: 'error'; message: string };
+
 export type ChannelCountMode = 'max' | 'clamped-max' | 'explicit';
 
 export type ChannelInterpretation = 'speakers' | 'discrete';
@@ -14,7 +18,7 @@ export type BiquadFilterType =
   | 'notch'
   | 'allpass';
 
-export type ContextState = 'running' | 'closed' | `suspended`;
+export type ContextState = 'running' | 'closed' | 'suspended';
 
 export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
 
@@ -40,9 +44,68 @@ export interface OfflineAudioContextOptions {
   sampleRate: number;
 }
 
-export interface AudioRecorderOptions {
+export enum FileDirectory {
+  Document = 1,
+  Cache = 2,
+}
+
+export enum FileFormat {
+  Wav = 1,
+  Caf = 2,
+  M4A = 3,
+  Flac = 4,
+}
+
+export enum IOSAudioQuality {
+  Min = 1,
+  Low = 2,
+  Medium = 3,
+  High = 4,
+  Max = 5,
+}
+
+export enum FlacCompressionLevel {
+  L0 = 1,
+  L1 = 2,
+  L2 = 3,
+  L3 = 4,
+  L4 = 5,
+  L5 = 6,
+  L6 = 7,
+  L7 = 8,
+  L8 = 9,
+}
+
+export enum BitDepth {
+  Bit16 = 1,
+  Bit24 = 2,
+  Bit32 = 3,
+}
+
+export interface FilePresetType {
+  bitRate: number;
   sampleRate: number;
-  bufferLengthInSamples: number;
+  bitDepth: BitDepth;
+  iosQuality: IOSAudioQuality;
+  flacCompressionLevel: FlacCompressionLevel;
+}
+
+export interface AudioRecorderFileOptions {
+  channelCount?: number;
+  batchDurationSeconds?: number;
+
+  format?: FileFormat;
+  preset?: FilePresetType;
+
+  directory?: FileDirectory;
+  subDirectory?: string;
+  fileNamePrefix?: string;
+}
+
+export interface FileInfo {
+  path: string;
+  size: number;
+  duration: number;
 }
 
 export type WindowType = 'blackman' | 'hann';
@@ -57,3 +120,25 @@ export interface ConvolverNodeOptions {
   buffer?: AudioBuffer | null;
   disableNormalization?: boolean;
 }
+
+export interface AudioRecorderCallbackOptions {
+  /**
+   * The desired sample rate (in Hz) for audio buffers delivered to the
+   * recording callback. Common values include 44100 or 48000 Hz. The actual
+   * sample rate may differ depending on hardware and system capabilities.
+   */
+  sampleRate: number;
+
+  /**
+   * The preferred size of each audio buffer, expressed as the number of samples
+   * per channel. Smaller buffers reduce latency but increase CPU load, while
+   * larger buffers improve efficiency at the cost of higher latency.
+   */
+  bufferLength: number;
+
+  /**
+   * The desired number of audio channels per buffer. Typically 1 for mono or 2
+   * for stereo recordings.
+   */
+  channelCount: number;
+}
diff --git a/packages/react-native-audio-api/src/utils/filePresets.ts b/packages/react-native-audio-api/src/utils/filePresets.ts
new file mode 100644
index 000000000..90ecfe337
--- /dev/null
+++ b/packages/react-native-audio-api/src/utils/filePresets.ts
@@ -0,0 +1,47 @@
+import {
+  BitDepth,
+  FilePresetType,
+  FlacCompressionLevel,
+  IOSAudioQuality,
+} from '../types';
+
+const LowQuality: FilePresetType = {
+  sampleRate: 22050,
+  bitRate: 48000,
+  bitDepth: BitDepth.Bit16,
+  flacCompressionLevel: FlacCompressionLevel.L0,
+  iosQuality: IOSAudioQuality.Low,
+};
+
+const MediumQuality: FilePresetType = {
+  sampleRate: 44100,
+  bitRate: 128000,
+  bitDepth: BitDepth.Bit16,
+  flacCompressionLevel: FlacCompressionLevel.L3,
+  iosQuality: IOSAudioQuality.Medium,
+};
+
+const HighQuality: FilePresetType = {
+  sampleRate: 48000,
+  bitRate: 192000,
+  bitDepth: BitDepth.Bit24,
+  flacCompressionLevel: FlacCompressionLevel.L5,
+  iosQuality: IOSAudioQuality.High,
+};
+
+const LosslessQuality: FilePresetType = {
+  sampleRate: 48000,
+  bitRate: 320000,
+  bitDepth: BitDepth.Bit24,
+  flacCompressionLevel: FlacCompressionLevel.L8,
+  iosQuality: IOSAudioQuality.High,
+};
+
+const FilePreset = {
+  Low: LowQuality,
+  Medium: MediumQuality,
+  High: HighQuality,
+  Lossless: LosslessQuality,
+} as const;
+
+export default FilePreset;
diff --git a/packages/react-native-audio-api/tsconfig.json b/packages/react-native-audio-api/tsconfig.json
index 77f5e973f..f0275810b 100644
--- a/packages/react-native-audio-api/tsconfig.json
+++ b/packages/react-native-audio-api/tsconfig.json
@@ -1,9 +1,10 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
+    "removeComments": false,
     "paths": {
       "react-native-audio-api": ["./src"]
-    },
+    }
   },
   "include": ["src"]
 }
diff --git a/prettier.config.js b/prettier.config.js
index e157bf449..2e13e3acd 100644
--- a/prettier.config.js
+++ b/prettier.config.js
@@ -2,6 +2,7 @@
 module.exports = {
   plugins: ['prettier-plugin-jsdoc'],
   bracketSameLine: true,
+  jsxBracketSameLine: false,
   printWidth: 80,
   singleQuote: true,
   trailingComma: 'es5',
diff --git a/tsconfig.json b/tsconfig.json
index fdba0ea2c..83c0dee3c 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -14,6 +14,7 @@
     "esModuleInterop": true,
     "strict": true,
     "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "removeComments": false
   }
 }
diff --git a/yarn.lock b/yarn.lock
index cf2221c95..600dc93e9 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1578,7 +1578,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@commitlint/cli@npm:^17.8.1":
+"@commitlint/cli@npm:^17.0.2":
   version: 17.8.1
   resolution: "@commitlint/cli@npm:17.8.1"
   dependencies:
@@ -1598,12 +1598,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@commitlint/config-conventional@npm:^17.0.2":
-  version: 17.8.1
-  resolution: "@commitlint/config-conventional@npm:17.8.1"
+"@commitlint/config-conventional@npm:17.0.2":
+  version: 17.0.2
+  resolution: "@commitlint/config-conventional@npm:17.0.2"
   dependencies:
-    conventional-changelog-conventionalcommits: "npm:^6.1.0"
-  checksum: 10/ce8ace1a13f3a797ed699ffa13dc46273a27e1dc3ae8a9d01492c0637a8592e4ed24bb32d9a43f8745a8690a52d77ea4a950d039977b0dbcbf834f8cbacf5def
+    conventional-changelog-conventionalcommits: "npm:^5.0.0"
+  checksum: 10/23745015d976c61ee7bb6b7f501d7306b5db97bfdf5851b829ecde6395a2afb218128ffa29be058b8276ca8b66a7297946d3f3eb0aabc182aba324a507b67e68
   languageName: node
   linkType: hard
 
@@ -1766,7 +1766,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@commitlint/types@npm:^17.8.1":
+"@commitlint/types@npm:^17.0.0, @commitlint/types@npm:^17.8.1":
   version: 17.8.1
   resolution: "@commitlint/types@npm:17.8.1"
   dependencies:
@@ -2735,29 +2735,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/eslint-config@npm:0.81.0":
-  version: 0.81.0
-  resolution: "@react-native/eslint-config@npm:0.81.0"
-  dependencies:
-    "@babel/core": "npm:^7.25.2"
-    "@babel/eslint-parser": "npm:^7.25.1"
-    "@react-native/eslint-plugin": "npm:0.81.0"
-    "@typescript-eslint/eslint-plugin": "npm:^7.1.1"
-    "@typescript-eslint/parser": "npm:^7.1.1"
-    eslint-config-prettier: "npm:^8.5.0"
-    eslint-plugin-eslint-comments: "npm:^3.2.0"
-    eslint-plugin-ft-flow: "npm:^2.0.1"
-    eslint-plugin-jest: "npm:^27.9.0"
-    eslint-plugin-react: "npm:^7.30.1"
-    eslint-plugin-react-hooks: "npm:^5.2.0"
-    eslint-plugin-react-native: "npm:^4.0.0"
-  peerDependencies:
-    eslint: ">=8"
-    prettier: ">=2"
-  checksum: 10/bc8eaf5e35399b48d870c09a56aaa800510b958d9f100e13dedf4ef386dcf6d48f88039332168456cd5b70754987c5fa332da2b46c88feb7a98d988b7b54e4b4
-  languageName: node
-  linkType: hard
-
 "@react-native/eslint-config@npm:0.82.0":
   version: 0.82.0
   resolution: "@react-native/eslint-config@npm:0.82.0"
@@ -2781,13 +2758,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@react-native/eslint-plugin@npm:0.81.0":
-  version: 0.81.0
-  resolution: "@react-native/eslint-plugin@npm:0.81.0"
-  checksum: 10/d82c379f5425f6153c931005684ca589311ea43180cdb265be4cef30f8ba36898b4ea662eb7ec3460bb0c5e41d18a0fac0867d27166dc65ff9373104efdd5331
-  languageName: node
-  linkType: hard
-
 "@react-native/eslint-plugin@npm:0.82.0":
   version: 0.82.0
   resolution: "@react-native/eslint-plugin@npm:0.82.0"
@@ -3334,29 +3304,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/eslint-plugin@npm:^7.1.1":
-  version: 7.18.0
-  resolution: "@typescript-eslint/eslint-plugin@npm:7.18.0"
-  dependencies:
-    "@eslint-community/regexpp": "npm:^4.10.0"
-    "@typescript-eslint/scope-manager": "npm:7.18.0"
-    "@typescript-eslint/type-utils": "npm:7.18.0"
-    "@typescript-eslint/utils": "npm:7.18.0"
-    "@typescript-eslint/visitor-keys": "npm:7.18.0"
-    graphemer: "npm:^1.4.0"
-    ignore: "npm:^5.3.1"
-    natural-compare: "npm:^1.4.0"
-    ts-api-utils: "npm:^1.3.0"
-  peerDependencies:
-    "@typescript-eslint/parser": ^7.0.0
-    eslint: ^8.56.0
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10/6ee4c61f145dc05f0a567b8ac01b5399ef9c75f58bc6e9a3ffca8927b15e2be2d4c3fd32a2c1a7041cc0848fdeadac30d9cb0d3bcd3835d301847a88ffd19c4d
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/eslint-plugin@npm:^8.36.0":
   version: 8.46.1
   resolution: "@typescript-eslint/eslint-plugin@npm:8.46.1"
@@ -3378,24 +3325,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/parser@npm:^7.1.1":
-  version: 7.18.0
-  resolution: "@typescript-eslint/parser@npm:7.18.0"
-  dependencies:
-    "@typescript-eslint/scope-manager": "npm:7.18.0"
-    "@typescript-eslint/types": "npm:7.18.0"
-    "@typescript-eslint/typescript-estree": "npm:7.18.0"
-    "@typescript-eslint/visitor-keys": "npm:7.18.0"
-    debug: "npm:^4.3.4"
-  peerDependencies:
-    eslint: ^8.56.0
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10/36b00e192a96180220ba100fcce3c777fc3e61a6edbdead4e6e75a744d9f0cbe3fabb5f1c94a31cce6b28a4e4d5de148098eec01296026c3c8e16f7f0067cb1e
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/parser@npm:^8.36.0":
   version: 8.46.1
   resolution: "@typescript-eslint/parser@npm:8.46.1"
@@ -3435,16 +3364,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/scope-manager@npm:7.18.0":
-  version: 7.18.0
-  resolution: "@typescript-eslint/scope-manager@npm:7.18.0"
-  dependencies:
-    "@typescript-eslint/types": "npm:7.18.0"
-    "@typescript-eslint/visitor-keys": "npm:7.18.0"
-  checksum: 10/9eb2ae5d69d9f723e706c16b2b97744fc016996a5473bed596035ac4d12429b3d24e7340a8235d704efa57f8f52e1b3b37925ff7c2e3384859d28b23a99b8bcc
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/scope-manager@npm:8.46.1":
   version: 8.46.1
   resolution: "@typescript-eslint/scope-manager@npm:8.46.1"
@@ -3464,23 +3383,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/type-utils@npm:7.18.0":
-  version: 7.18.0
-  resolution: "@typescript-eslint/type-utils@npm:7.18.0"
-  dependencies:
-    "@typescript-eslint/typescript-estree": "npm:7.18.0"
-    "@typescript-eslint/utils": "npm:7.18.0"
-    debug: "npm:^4.3.4"
-    ts-api-utils: "npm:^1.3.0"
-  peerDependencies:
-    eslint: ^8.56.0
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10/bcc7958a4ecdddad8c92e17265175773e7dddf416a654c1a391e69cb16e43960b39d37b6ffa349941bf3635e050f0ca7cd8f56ec9dd774168f2bbe7afedc9676
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/type-utils@npm:8.46.1":
   version: 8.46.1
   resolution: "@typescript-eslint/type-utils@npm:8.46.1"
@@ -3504,13 +3406,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/types@npm:7.18.0":
-  version: 7.18.0
-  resolution: "@typescript-eslint/types@npm:7.18.0"
-  checksum: 10/0e30c73a3cc3c67dd06360a5a12fd12cee831e4092750eec3d6c031bdc4feafcb0ab1d882910a73e66b451a4f6e1dd015e9e2c4d45bf6bf716a474e5d123ddf0
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/types@npm:8.46.1, @typescript-eslint/types@npm:^8.46.1":
   version: 8.46.1
   resolution: "@typescript-eslint/types@npm:8.46.1"
@@ -3543,25 +3438,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/typescript-estree@npm:7.18.0":
-  version: 7.18.0
-  resolution: "@typescript-eslint/typescript-estree@npm:7.18.0"
-  dependencies:
-    "@typescript-eslint/types": "npm:7.18.0"
-    "@typescript-eslint/visitor-keys": "npm:7.18.0"
-    debug: "npm:^4.3.4"
-    globby: "npm:^11.1.0"
-    is-glob: "npm:^4.0.3"
-    minimatch: "npm:^9.0.4"
-    semver: "npm:^7.6.0"
-    ts-api-utils: "npm:^1.3.0"
-  peerDependenciesMeta:
-    typescript:
-      optional: true
-  checksum: 10/b01e66235a91aa4439d02081d4a5f8b4a7cf9cb24f26b334812f657e3c603493e5f41e5c1e89cf4efae7d64509fa1f73affc16afc5e15cb7f83f724577c82036
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/typescript-estree@npm:8.46.1":
   version: 8.46.1
   resolution: "@typescript-eslint/typescript-estree@npm:8.46.1"
@@ -3582,20 +3458,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/utils@npm:7.18.0":
-  version: 7.18.0
-  resolution: "@typescript-eslint/utils@npm:7.18.0"
-  dependencies:
-    "@eslint-community/eslint-utils": "npm:^4.4.0"
-    "@typescript-eslint/scope-manager": "npm:7.18.0"
-    "@typescript-eslint/types": "npm:7.18.0"
-    "@typescript-eslint/typescript-estree": "npm:7.18.0"
-  peerDependencies:
-    eslint: ^8.56.0
-  checksum: 10/f43fedb4f4d2e3836bdf137889449063a55c0ece74fdb283929cd376197b992313be8ef4df920c1c801b5c3076b92964c84c6c3b9b749d263b648d0011f5926e
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/utils@npm:8.46.1, @typescript-eslint/utils@npm:^8.0.0":
   version: 8.46.1
   resolution: "@typescript-eslint/utils@npm:8.46.1"
@@ -3639,16 +3501,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typescript-eslint/visitor-keys@npm:7.18.0":
-  version: 7.18.0
-  resolution: "@typescript-eslint/visitor-keys@npm:7.18.0"
-  dependencies:
-    "@typescript-eslint/types": "npm:7.18.0"
-    eslint-visitor-keys: "npm:^3.4.3"
-  checksum: 10/b7cfe6fdeae86c507357ac6b2357813c64fb2fbf1aaf844393ba82f73a16e2599b41981b34200d9fc7765d70bc3a8181d76b503051e53f04bcb7c9afef637eab
-  languageName: node
-  linkType: hard
-
 "@typescript-eslint/visitor-keys@npm:8.46.1":
   version: 8.46.1
   resolution: "@typescript-eslint/visitor-keys@npm:8.46.1"
@@ -4859,15 +4711,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"commitlint@npm:^17.0.2":
-  version: 17.8.1
-  resolution: "commitlint@npm:17.8.1"
+"commitlint@npm:17.0.2":
+  version: 17.0.2
+  resolution: "commitlint@npm:17.0.2"
   dependencies:
-    "@commitlint/cli": "npm:^17.8.1"
-    "@commitlint/types": "npm:^17.8.1"
+    "@commitlint/cli": "npm:^17.0.2"
+    "@commitlint/types": "npm:^17.0.0"
   bin:
     commitlint: cli.js
-  checksum: 10/319f5b209bc08e3823ed987f93ab979213e9c03297a16c51e39c8c35862472a98313c9d948b1d5b201828d5015c8ef6bc788d003da15a9c818b3886f3bd3514a
+  checksum: 10/82d125427e9bb5bcbf6a8eba7ff4be51718103df83388f5bbc81a52a2cb3defdfcf8df05036c9c8b34186e26916d1577922c915ce3bea4deb1f559d7706f172e
   languageName: node
   linkType: hard
 
@@ -4907,7 +4759,7 @@ __metadata:
     react-native-svg: "npm:15.14.0"
     react-native-worklets: "npm:0.6.1"
     react-test-renderer: "npm:19.1.1"
-    typescript: "npm:5.8.3"
+    typescript: "npm:~5.8.3"
   peerDependencies:
     react: "*"
     react-native: "*"
@@ -4983,12 +4835,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"conventional-changelog-conventionalcommits@npm:^6.1.0":
-  version: 6.1.0
-  resolution: "conventional-changelog-conventionalcommits@npm:6.1.0"
+"conventional-changelog-conventionalcommits@npm:^5.0.0":
+  version: 5.0.0
+  resolution: "conventional-changelog-conventionalcommits@npm:5.0.0"
   dependencies:
     compare-func: "npm:^2.0.0"
-  checksum: 10/7e5caef7d65b381a0b302534058acff83adc7a907094c85379ef138c35f2aa043cf8e7a3bef30f42078dcc4bff0e8bc763b179c007dd732d92856fae0607a4bc
+    lodash: "npm:^4.17.15"
+    q: "npm:^1.5.1"
+  checksum: 10/cf67329999ed5798fcca243a5d66479f6f8f2122e61a3144186ae3fd15481e9d6647ed7ca74d59d5cfdc568f8c4298ae4cd90b389aecd285cc6a1ba823d85a96
   languageName: node
   linkType: hard
 
@@ -5962,19 +5816,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint-plugin-ft-flow@npm:^3.0.11":
-  version: 3.0.11
-  resolution: "eslint-plugin-ft-flow@npm:3.0.11"
-  dependencies:
-    lodash: "npm:^4.17.21"
-    string-natural-compare: "npm:^3.0.1"
-  peerDependencies:
-    eslint: ^8.56.0 || ^9.0.0
-    hermes-eslint: ">=0.15.0"
-  checksum: 10/f516500f10e7659cac7cf42adbf15aa41dbe4ac75cdc5893658b073e0564acedba8ceb33c20de999c546208d3e94f03ef178df4d124cef113e179003070b53c7
-  languageName: node
-  linkType: hard
-
 "eslint-plugin-import@npm:^2.25.4":
   version: 2.32.0
   resolution: "eslint-plugin-import@npm:2.32.0"
@@ -6004,7 +5845,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eslint-plugin-jest@npm:^27.2.1, eslint-plugin-jest@npm:^27.9.0":
+"eslint-plugin-jest@npm:^27.2.1":
   version: 27.9.0
   resolution: "eslint-plugin-jest@npm:27.9.0"
   dependencies:
@@ -7308,7 +7149,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ignore@npm:^5.0.5, ignore@npm:^5.2.0, ignore@npm:^5.2.4, ignore@npm:^5.3.1":
+"ignore@npm:^5.0.5, ignore@npm:^5.2.0, ignore@npm:^5.2.4":
   version: 5.3.2
   resolution: "ignore@npm:5.3.2"
   checksum: 10/cceb6a457000f8f6a50e1196429750d782afce5680dd878aa4221bd79972d68b3a55b4b1458fc682be978f4d3c6a249046aa0880637367216444ab7b014cfc98
@@ -10750,6 +10591,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"q@npm:^1.5.1":
+  version: 1.5.1
+  resolution: "q@npm:1.5.1"
+  checksum: 10/70c4a30b300277165cd855889cd3aa681929840a5940413297645c5691e00a3549a2a4153131efdf43fe8277ee8cf5a34c9636dcb649d83ad47f311a015fd380
+  languageName: node
+  linkType: hard
+
 "qs@npm:6.13.0":
   version: 6.13.0
   resolution: "qs@npm:6.13.0"
@@ -10871,21 +10719,20 @@ __metadata:
   version: 0.0.0-use.local
   resolution: "react-native-audio-api-monorepo@workspace:."
   dependencies:
-    "@commitlint/config-conventional": "npm:^17.0.2"
+    "@commitlint/config-conventional": "npm:17.0.2"
     "@evilmartians/lefthook": "npm:^1.5.0"
-    "@react-native/eslint-config": "npm:0.81.0"
+    "@react-native/eslint-config": "npm:0.82.0"
     "@types/raf": "npm:^3.4.3"
-    commitlint: "npm:^17.0.2"
+    commitlint: "npm:17.0.2"
     eslint: "npm:^8.57.0"
     eslint-config-prettier: "npm:^9.0.0"
-    eslint-plugin-ft-flow: "npm:^3.0.11"
     eslint-plugin-jsdoc: "npm:^50.2.2"
     eslint-plugin-prettier: "npm:^5.0.1"
     eslint-plugin-react: "npm:^7.34.3"
     hermes-eslint: "npm:^0.26.0"
     prettier: "npm:^3.3.3"
     prettier-plugin-jsdoc: "npm:^1.3.0"
-    typescript: "npm:5.8.3"
+    typescript: "npm:~5.8.3"
   languageName: unknown
   linkType: soft
 
@@ -10897,7 +10744,7 @@ __metadata:
     "@babel/core": "npm:^7.25.2"
     "@babel/preset-env": "npm:^7.25.3"
     "@babel/types": "npm:^7.20.0"
-    "@commitlint/config-conventional": "npm:^17.0.2"
+    "@commitlint/config-conventional": "npm:17.0.2"
     "@evilmartians/lefthook": "npm:^1.5.0"
     "@expo/config-plugins": "npm:^9.0.0"
     "@expo/config-types": "npm:^53.0.4"
@@ -10915,7 +10762,7 @@ __metadata:
     "@types/react-test-renderer": "npm:^19.1.0"
     "@types/semver": "npm:7.7.1"
     babel-plugin-module-resolver: "npm:^4.1.0"
-    commitlint: "npm:^17.0.2"
+    commitlint: "npm:17.0.2"
     del-cli: "npm:^5.1.0"
     eslint: "npm:^8.57.0"
     eslint-config-prettier: "npm:^8.3.0"
@@ -10937,7 +10784,7 @@ __metadata:
     react-native: "npm:0.82.0"
     react-native-builder-bob: "npm:0.33.1"
     turbo: "npm:^1.10.7"
-    typescript: "npm:5.8.3"
+    typescript: "npm:~5.8.3"
   peerDependencies:
     react: "*"
     react-native: "*"
@@ -12500,15 +12347,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ts-api-utils@npm:^1.3.0":
-  version: 1.4.3
-  resolution: "ts-api-utils@npm:1.4.3"
-  peerDependencies:
-    typescript: ">=4.2.0"
-  checksum: 10/713c51e7392323305bd4867422ba130fbf70873ef6edbf80ea6d7e9c8f41eeeb13e40e8e7fe7cd321d74e4864777329797077268c9f570464303a1723f1eed39
-  languageName: node
-  linkType: hard
-
 "ts-api-utils@npm:^2.1.0":
   version: 2.1.0
   resolution: "ts-api-utils@npm:2.1.0"
@@ -12785,7 +12623,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:5.8.3":
+"typescript@npm:~5.8.3":
   version: 5.8.3
   resolution: "typescript@npm:5.8.3"
   bin:
@@ -12795,17 +12633,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@npm:^4.6.4 || ^5.2.2":
-  version: 5.9.2
-  resolution: "typescript@npm:5.9.2"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 10/cc2fe6c822819de5d453fa25aa9f32096bf70dde215d481faa1ad84a283dfb264e33988ed8f6d36bc803dd0b16dbe943efa311a798ef76d5b3892a05dfbfd628
-  languageName: node
-  linkType: hard
-
-"typescript@patch:typescript@npm%3A5.8.3#optional!builtin<compat/typescript>":
+"typescript@patch:typescript@npm%3A~5.8.3#optional!builtin<compat/typescript>":
   version: 5.8.3
   resolution: "typescript@patch:typescript@npm%3A5.8.3#optional!builtin<compat/typescript>::version=5.8.3&hash=8c6c40"
   bin:
@@ -12815,16 +12643,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typescript@patch:typescript@npm%3A^4.6.4 || ^5.2.2#optional!builtin<compat/typescript>":
-  version: 5.9.2
-  resolution: "typescript@patch:typescript@npm%3A5.9.2#optional!builtin<compat/typescript>::version=5.9.2&hash=8c6c40"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 10/a8606016982f2f46ed085e9b4b84d8a5251b42ff0560c995c20f3c3ab9543e37c1015d92ab2f1cc7b2af2b499d12bac57e11789da271fb3225af8ec0b24e5b64
-  languageName: node
-  linkType: hard
-
 "unbox-primitive@npm:^1.1.0":
   version: 1.1.0
   resolution: "unbox-primitive@npm:1.1.0"