react-native-audio-api 0.6.0-rc.1 → 0.6.0-rc.2

package/README.md

@@ -1,43 +1,56 @@
 <img src="./assets/react-native-audio-api-gh-cover.png?v0.0.1" alt="React Native Audio API" width="100%">
 
-### React Native Audio API
+### High-performance audio engine for React Native based on web audio api specification
+
+[![NPM latest](https://img.shields.io/npm/v/react-native-audio-api/latest)](https://www.npmjs.com/package/react-native-audio-api)
+[![NPM next](https://img.shields.io/npm/v/react-native-audio-api/next)](https://www.npmjs.com/package/react-native-audio-api?activeTab=versions)
+[![github ci](https://img.shields.io/github/actions/workflow/status/software-mansion/react-native-audio-api/ci.yml)](https://github.com/software-mansion/react-native-audio-api/actions)
 
 `react-native-audio-api` provides system for controlling audio in React Native environment compatible with Web Audio API specification,
 allowing developers to generate and modify audio in exact same way it is possible in browsers.
 
 ## Installation
 
-1. Install `react-native-audio-api` library
+check out the [Getting Started](https://docs.swmansion.com/react-native-audio-api/fundamentals/getting-started) section of our documentation for detailed instructions!
 
-   ```bash
-   # using npm
-   npm install react-native-audio-api
+## Roadmap
 
-   # or using yarn
-   yarn add react-native-audio-api
-   ```
+- <sub>[![Released in 0.1.0](https://img.shields.io/badge/Released_in-0.1.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.1.0)</sub> **Sound synthesis and system audio** 🐣 <br />
+  Access to devices audio engines and threads, basic nodes for sound synthesis, simple effects and audio graph implementation
+  <br />
 
-## Usage with expo
+- <sub>[![Released in 0.2.0](https://img.shields.io/badge/Released_in-0.2.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.2.0)</sub> **Graph Processing** 🛎️ <br />
+  Support for multi-channel audio processing, audio-graph route optimizations, improved react-native layer for managing audio nodes
+  <br />
+- <sub>[![Released in 0.3.2](https://img.shields.io/badge/Released_in-0.3.2-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.3.2)</sub> **Audio Files** 🎸 <br />
+  Support for local and remote audio file resources: MP3, WAV, FLAC.
+  <br />
 
-`react-native-audio-api` contains native custom code and isn't part of the Expo Go application. In order to be available in expo managed builds, you have to use Expo development build. Simplest way on starting local expo dev builds, is to use:
+- <sub>[![Released in 0.4.0](https://img.shields.io/badge/Released_in-0.4.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.4.0)</sub> **Analyser Node** 🌊 <br />
+  Ability to draw, animate or simply debug audio data in time or frequency domain.
+  <br />
 
-  ```bash
-    # Build native iOS project
-    npx expo run:ios
-    # Build native Android project
-    npx expo run:android
-  ```
+- <sub>[![Released in 0.5.0](https://img.shields.io/badge/Released_in-0.5.0-green)](https://github.com/software-mansion/react-native-audio-api/releases/tag/0.5.0)</sub> **Pitch correction, extending the web** 💥 <br />
+  Ability to modify playback speed without affecting pitch of the sound
+  <br />
 
-To learn more about expo development builds, please check out [Development Builds Documentation](https://docs.expo.dev/develop/development-builds/introduction/).
+- <sub>![Coming in 0.6.0](https://img.shields.io/badge/Coming_in-0.6.0-blue)</sub> **System configuration** 🛠️ <br />
+  Full control of system audio settings, remote controls, lock screen integration and most importantly configurable background modes
+  <br />
 
-## Documentation
+- **Microphone support** 🎙️ <br />
+  Grab audio data from device microphone or connected device, connect it to the audio graph or stream through the internet
+  <br />
 
-Check out our dedicated documentation page for info about this library, API reference and more:
-[https://software-mansion.github.io/react-native-audio-api/](https://software-mansion.github.io/react-native-audio-api/)
+- **Connect audio param** 🤞 <br />
+  Ability to connect Audio nodes to audio params, which will allow for powerful and efficient modulation of audio parameters, creating effects like tremolo, vibrato or complex envelope followers.
+  <br />
 
-You can also check out [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API) for fully detailed description of the audio api.
+- **JS Audio Worklets** 🐎 <br />
+  Ability to run JS functions connected to the audio graph running on audio thread allowing for full customization of what happens to the audio signal.
+  <br />
 
-## Coverage
+## Web Audio API Specification Coverage
 
 Our current coverage of Web Audio API specification can be found here: [Web Audio API coverage](https://software-mansion.github.io/react-native-audio-api/other/web-audio-api-coverage).
 

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp

@@ -0,0 +1,73 @@
+#include <audioapi/android/core/AndroidAudioRecorder.h>
+#include <audioapi/core/Constants.h>
+#include <audioapi/utils/AudioArray.h>
+#include <audioapi/utils/AudioBus.h>
+
+namespace audioapi {
+
+AndroidAudioRecorder::AndroidAudioRecorder(
+    float sampleRate,
+    int bufferLength,
+    const std::function<void(void)> &onError,
+    const std::function<void(void)> &onStatusChange,
+    const std::function<void(std::shared_ptr<AudioBus>, int, double)>
+        &onAudioReady)
+    : AudioRecorder(
+          sampleRate,
+          bufferLength,
+          onError,
+          onStatusChange,
+          onAudioReady) {
+  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))
+      ->setFramesPerDataCallback(bufferLength)
+      ->openStream(mStream_);
+}
+
+AndroidAudioRecorder::~AndroidAudioRecorder() {
+  AudioRecorder::~AudioRecorder();
+
+  if (mStream_) {
+    mStream_->requestStop();
+    mStream_->close();
+    mStream_.reset();
+  }
+}
+
+void AndroidAudioRecorder::start() {
+  if (mStream_) {
+    mStream_->requestStart();
+  }
+}
+
+void AndroidAudioRecorder::stop() {
+  if (mStream_) {
+    mStream_->requestStop();
+  }
+}
+
+DataCallbackResult AndroidAudioRecorder::onAudioReady(
+    oboe::AudioStream *oboeStream,
+    void *audioData,
+    int32_t numFrames) {
+  auto buffer = static_cast<float *>(audioData);
+
+  auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
+  memcpy(bus->getChannel(0)->getData(), buffer, numFrames * sizeof(float));
+  auto when = static_cast<double>(
+      oboeStream->getTimestamp(CLOCK_MONOTONIC).value().timestamp);
+
+  onAudioReady_(bus, numFrames, when);
+
+  return DataCallbackResult::Continue;
+}
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <audioapi/core/inputs/AudioRecorder.h>
+
+#include <oboe/Oboe.h>
+#include <functional>
+#include <memory>
+
+namespace audioapi {
+
+using namespace oboe;
+
+class AudioBus;
+
+class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorder {
+ public:
+    AndroidAudioRecorder(float sampleRate,
+                         int bufferLength,
+                         const std::function<void(void)> &onError,
+                         const std::function<void(void)> &onStatusChange,
+                         const std::function<void(std::shared_ptr<AudioBus>, int, double)> &onAudioReady);
+
+    ~AndroidAudioRecorder() override;
+
+    void start() override;
+    void stop() override;
+
+    DataCallbackResult onAudioReady(
+            AudioStream *oboeStream,
+            void *audioData,
+            int32_t numFrames) override;
+
+ private:
+    std::shared_ptr<AudioStream> mStream_;
+};
+
+} // namespace audioapi

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.cpp

@@ -27,11 +27,13 @@ AudioPlayer::AudioPlayer(
   isInitialized_ = true;
 }
 
-float AudioPlayer::getSampleRate() const {
-  return sampleRate_;
+void AudioPlayer::start() {
+  if (mStream_) {
+    mStream_->requestStart();
+  }
 }
 
-void AudioPlayer::start() {
+void AudioPlayer::resume() {
   if (mStream_) {
     mStream_->requestStart();
   }
@@ -47,13 +49,7 @@ void AudioPlayer::stop() {
   }
 }
 
-void AudioPlayer::resume() {
-  if (mStream_) {
-    mStream_->requestStart();
-  }
-}
-
-void AudioPlayer::suspend() {
+void AudioPlayer::pause() {
   if (mStream_) {
     mStream_->requestPause();
   }

package/android/src/main/cpp/audioapi/android/core/AudioPlayer.h

@@ -18,11 +18,10 @@ class AudioPlayer : public AudioStreamDataCallback {
       const std::function<void(std::shared_ptr<AudioBus>, int)> &renderAudio,
       float sampleRate);
 
-  [[nodiscard]] float getSampleRate() const;
   void start();
-  void stop();
   void resume();
-  void suspend();
+  void stop();
+  void pause();
 
   DataCallbackResult onAudioReady(
       AudioStream *oboeStream,

package/android/src/main/java/com/swmansion/audioapi/AudioManagerModule.kt

@@ -14,24 +14,24 @@ class AudioManagerModule(
     const val NAME = "AudioManagerModule"
   }
 
-  private val mediaSessionManager: MediaSessionManager = MediaSessionManager(reactContext)
-
   init {
     try {
       System.loadLibrary("react-native-audio-api")
     } catch (exception: UnsatisfiedLinkError) {
       throw RuntimeException("Could not load native module AudioAPIModule", exception)
     }
+
+    MediaSessionManager.initialize(reactContext)
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun setLockScreenInfo(info: ReadableMap?) {
-    mediaSessionManager.setLockScreenInfo(info)
+    MediaSessionManager.setLockScreenInfo(info)
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun resetLockScreenInfo() {
-    mediaSessionManager.resetLockScreenInfo()
+    MediaSessionManager.resetLockScreenInfo()
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
@@ -39,7 +39,7 @@ class AudioManagerModule(
     name: String,
     enabled: Boolean,
   ) {
-    mediaSessionManager.enableRemoteCommand(name, enabled)
+    MediaSessionManager.enableRemoteCommand(name, enabled)
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
@@ -47,16 +47,18 @@ class AudioManagerModule(
     category: String?,
     mode: String?,
     options: ReadableArray?,
-    active: Boolean,
   ) {
     // Nothing to do here
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
-  fun getDevicePreferredSampleRate(): Double = mediaSessionManager.getDevicePreferredSampleRate()
+  fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun observeAudioInterruptions(enable: Boolean) = MediaSessionManager.observeAudioInterruptions(enable)
 
   @ReactMethod(isBlockingSynchronousMethod = true)
-  fun observeAudioInterruptions(enable: Boolean) = mediaSessionManager.observeAudioInterruptions(enable)
+  fun observeVolumeChanges(enable: Boolean) = MediaSessionManager.observeVolumeChanges(enable)
 
   override fun getName(): String = NAME
 }

package/android/src/main/java/com/swmansion/audioapi/system/MediaNotificationManager.kt

@@ -207,7 +207,7 @@ class MediaNotificationManager(
     return NotificationCompat.Action(icon, title, i)
   }
 
-  inner class NotificationService : Service() {
+  class NotificationService : Service() {
     private val binder = LocalBinder()
     private var notification: Notification? = null
 
@@ -231,9 +231,9 @@ class MediaNotificationManager(
         val intent = Intent(this, NotificationService::class.java)
         ContextCompat.startForegroundService(this, intent)
         notification =
-          MediaNotificationManager(reactContext, notificationId, channelId)
-            .prepareNotification(NotificationCompat.Builder(this, channelId), false)
-        startForeground(notificationId, notification)
+          MediaSessionManager.mediaNotificationManager
+            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.channelId), false)
+        startForeground(MediaSessionManager.notificationId, notification)
       }
     }
 
@@ -241,9 +241,9 @@ class MediaNotificationManager(
       super.onCreate()
       try {
         notification =
-          MediaNotificationManager(reactContext, notificationId, channelId)
-            .prepareNotification(NotificationCompat.Builder(this, channelId), false)
-        startForeground(notificationId, notification)
+          MediaSessionManager.mediaNotificationManager
+            .prepareNotification(NotificationCompat.Builder(this, MediaSessionManager.channelId), false)
+        startForeground(MediaSessionManager.notificationId, notification)
       } catch (ex: Exception) {
         Log.w("AudioManagerModule", "Error starting service: ${ex.message}")
       }

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionEventEmitter.kt

@@ -73,6 +73,10 @@ class MediaSessionEventEmitter(
     sendEvent("onInterruption", values)
   }
 
+  fun onVolumeChange(values: Map<String, Number>) {
+    sendEvent("onVolumeChange", values)
+  }
+
   private fun stopForegroundService() {
     NotificationManagerCompat.from(reactContext).cancel(notificationId)
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

package/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt

@@ -18,21 +18,19 @@ import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
 
-class MediaSessionManager(
-  val reactContext: ReactApplicationContext,
-) {
+object MediaSessionManager {
+  lateinit var reactContext: ReactApplicationContext
   val notificationId = 100
   val channelId = "react-native-audio-api"
 
-  private val audioManager: AudioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-  val mediaSession: MediaSessionCompat = MediaSessionCompat(reactContext, "MediaSessionManager")
-  val mediaNotificationManager: MediaNotificationManager
-  private val lockScreenManager: LockScreenManager
-  val eventEmitter: MediaSessionEventEmitter =
-    MediaSessionEventEmitter(reactContext, notificationId)
-  private val audioFocusListener: AudioFocusListener
-  private val mediaReceiver: MediaReceiver =
-    MediaReceiver(reactContext, this)
+  private lateinit var audioManager: AudioManager
+  lateinit var mediaSession: MediaSessionCompat
+  lateinit var mediaNotificationManager: MediaNotificationManager
+  private lateinit var lockScreenManager: LockScreenManager
+  lateinit var eventEmitter: MediaSessionEventEmitter
+  private lateinit var audioFocusListener: AudioFocusListener
+  private lateinit var volumeChangeListener: VolumeChangeListener
+  private lateinit var mediaReceiver: MediaReceiver
 
   private val connection =
     object : ServiceConnection {
@@ -60,13 +58,19 @@ class MediaSessionManager(
       }
     }
 
-  init {
+  fun initialize(reactContext: ReactApplicationContext) {
+    this.reactContext = reactContext
+    this.audioManager = reactContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    this.mediaSession = MediaSessionCompat(reactContext, "MediaSessionManager")
+
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       createChannel()
     }
 
     this.mediaNotificationManager = MediaNotificationManager(reactContext, notificationId, channelId)
     this.lockScreenManager = LockScreenManager(reactContext, mediaSession, mediaNotificationManager, channelId)
+    this.eventEmitter = MediaSessionEventEmitter(reactContext, notificationId)
+    this.mediaReceiver = MediaReceiver(reactContext, this)
     this.mediaSession.setCallback(MediaSessionCallback(eventEmitter, lockScreenManager))
 
     val filter = IntentFilter()
@@ -87,6 +91,7 @@ class MediaSessionManager(
     }
 
     this.audioFocusListener = AudioFocusListener(audioManager, eventEmitter, lockScreenManager)
+    this.volumeChangeListener = VolumeChangeListener(audioManager, eventEmitter)
 
     val myIntent = Intent(reactContext, MediaNotificationManager.NotificationService::class.java)
 
@@ -129,6 +134,19 @@ class MediaSessionManager(
     }
   }
 
+  fun observeVolumeChanges(observe: Boolean) {
+    if (observe) {
+      ContextCompat.registerReceiver(
+        reactContext,
+        volumeChangeListener,
+        volumeChangeListener.getIntentFilter(),
+        ContextCompat.RECEIVER_NOT_EXPORTED,
+      )
+    } else {
+      reactContext.unregisterReceiver(volumeChangeListener)
+    }
+  }
+
   @RequiresApi(Build.VERSION_CODES.O)
   private fun createChannel() {
     val notificationManager =

package/android/src/main/java/com/swmansion/audioapi/system/VolumeChangeListener.kt

@@ -0,0 +1,27 @@
+package com.swmansion.audioapi.system
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+
+class VolumeChangeListener(
+  private val audioManager: AudioManager,
+  private val eventEmitter: MediaSessionEventEmitter,
+) : BroadcastReceiver() {
+  override fun onReceive(
+    context: Context?,
+    intent: Intent?,
+  ) {
+    val currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC).toDouble()
+    val maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC).toDouble()
+    eventEmitter.onVolumeChange(mapOf("value" to currentVolume / maxVolume))
+  }
+
+  fun getIntentFilter(): IntentFilter {
+    val intentFilter = IntentFilter()
+    intentFilter.addAction("android.media.VOLUME_CHANGED_ACTION")
+    return intentFilter
+  }
+}

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -3,8 +3,10 @@
 #include <audioapi/jsi/JsiPromise.h>
 #include <audioapi/core/AudioContext.h>
 #include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/HostObjects/AudioContextHostObject.h>
 #include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
+#include <audioapi/HostObjects/AudioRecorderHostObject.h>
 
 #include <memory>
 
@@ -16,11 +18,12 @@ class AudioAPIModuleInstaller {
  public:
   static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
     auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker);
+    auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, jsCallInvoker);
     auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createAudioContext", createAudioContext);
-    jsiRuntime->global().setProperty(
-        *jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
+
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
+    jsiRuntime->global().setProperty(*jsiRuntime, "createOfflineAudioContext", createOfflineAudioContext);
   }
 
  private:
@@ -60,7 +63,7 @@ class AudioAPIModuleInstaller {
             auto length = static_cast<size_t>(args[1].getNumber());
             auto sampleRate = static_cast<float>(args[2].getNumber());
 
-          std::shared_ptr<OfflineAudioContext> offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate);
+          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate);
           auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
               offlineAudioContext, jsiRuntime, jsCallInvoker);
 
@@ -68,6 +71,27 @@ class AudioAPIModuleInstaller {
               runtime, audioContextHostObject);
         });
   }
+
+  static jsi::Function getCreateAudioRecorderFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime,
+        jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
+        0,
+        [jsCallInvoker](
+            jsi::Runtime &runtime,
+            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>(&runtime, jsCallInvoker, sampleRate, bufferLength);
+
+          return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
+        });
+  }
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/AnalyserNodeHostObject.h

@@ -145,4 +145,5 @@ class AnalyserNodeHostObject : public AudioNodeHostObject {
     analyserNode->setWindowType(value.getString(runtime).utf8(runtime));
   }
 };
+
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/AudioRecorderHostObject.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/core/inputs/AudioRecorder.h>
+
+#ifdef ANDROID
+#include <audioapi/android/core/AndroidAudioRecorder.h>
+#else
+#include <audioapi/ios/core/IOSAudioRecorder.h>
+#endif
+
+#include <memory>
+#include <utility>
+#include <vector>
+#include <cstdio>
+
+namespace audioapi {
+using namespace facebook;
+
+class AudioRecorderHostObject : public JsiHostObject {
+ public:
+  explicit AudioRecorderHostObject(
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker,
+      float sampleRate,
+      int bufferLength)
+      : callInvoker_(callInvoker) {
+    promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+
+#ifdef ANDROID
+    audioRecorder_ = std::make_shared<AndroidAudioRecorder>(
+      sampleRate,
+      bufferLength,
+      this->getOnError(),
+      this->getOnStatusChange(),
+      this->getOnAudioReady()
+    );
+#else
+  audioRecorder_ = std::make_shared<IOSAudioRecorder>(
+      sampleRate,
+      bufferLength,
+      this->getOnError(),
+      this->getOnStatusChange(),
+      this->getOnAudioReady()
+    );
+#endif
+
+    addFunctions(
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, start),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, stop),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, onAudioReady),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, onError),
+      JSI_EXPORT_FUNCTION(AudioRecorderHostObject, onStatusChange));
+  }
+
+  ~AudioRecorderHostObject() override {
+    errorCallback_ = nullptr;
+    audioReadyCallback_ = nullptr;
+    statusChangeCallback_ = nullptr;
+  }
+
+  JSI_HOST_FUNCTION(start) {
+    audioRecorder_->start();
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(stop) {
+    audioRecorder_->stop();
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(onAudioReady) {
+    audioReadyCallback_ = std::make_unique<jsi::Function>(args[0].getObject(runtime).getFunction(runtime));
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(onError) {
+    errorCallback_ = std::make_unique<jsi::Function>(args[0].getObject(runtime).getFunction(runtime));
+
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(onStatusChange) {
+    statusChangeCallback_ = std::make_unique<jsi::Function>(args[0].getObject(runtime).getFunction(runtime));
+
+    return jsi::Value::undefined();
+  }
+
+ protected:
+  std::shared_ptr<AudioRecorder> audioRecorder_;
+  std::shared_ptr<PromiseVendor> promiseVendor_;
+  std::shared_ptr<react::CallInvoker> callInvoker_;
+
+  std::unique_ptr<jsi::Function> errorCallback_;
+  std::unique_ptr<jsi::Function> audioReadyCallback_;
+  std::unique_ptr<jsi::Function> statusChangeCallback_;
+
+  std::function<void(std::shared_ptr<AudioBus>, int, double)> getOnAudioReady() {
+    return [this](const std::shared_ptr<AudioBus> &bus, int numFrames, double when) {
+      if (audioReadyCallback_ == nullptr) {
+        return;
+      }
+
+      callInvoker_->invokeAsync([this, bus = bus, numFrames, when](jsi::Runtime &runtime) {
+        auto buffer = std::make_shared<AudioBuffer>(bus);
+        auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+
+        audioReadyCallback_->call(
+          runtime,
+          jsi::Object::createFromHostObject(runtime, bufferHostObject),
+          jsi::Value(numFrames),
+          jsi::Value(when)
+        );
+      });
+    };
+  }
+
+  std::function<void(void)> getOnError() {
+    return [this]() {
+      if (errorCallback_ == nullptr) {
+        return;
+      }
+
+      callInvoker_->invokeAsync([this](jsi::Runtime &runtime) {
+        errorCallback_->call(runtime);
+      });
+    };
+  }
+
+  std::function<void(void)> getOnStatusChange() {
+    return [this]() {
+      if (statusChangeCallback_ == nullptr) {
+        return;
+      }
+
+      callInvoker_->invokeAsync([this](jsi::Runtime &runtime) {
+        statusChangeCallback_->call(runtime);
+      });
+    };
+  }
+};
+
+} // namespace audioapi