react-native-audio-api 0.8.3-nightly-245398c-20250924 → 0.8.3-nightly-2295d0d-20250926

package/RNAudioAPI.podspec

@@ -4,7 +4,7 @@ package_json = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
 $new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 
-folly_flags = "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32"
+folly_flags = "-DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32"
 fabric_flags = $new_arch_enabled ? '-DRCT_NEW_ARCH_ENABLED' : ''
 version_flag = "-DAUDIOAPI_VERSION=#{package_json['version']}"
 
@@ -42,18 +42,18 @@ Pod::Spec.new do |s|
   # Assumes Pods dir is nested under ios project dir
   ios_dir = File.join(Pod::Config.instance.project_pods_root, '..')
   rn_audio_dir_relative = Pathname.new(__dir__).relative_path_from(ios_dir).to_s
+
   external_dir_relative = "common/cpp/audioapi/external"
   lib_dir = "$(PROJECT_DIR)/#{rn_audio_dir_relative}/#{external_dir_relative}/$(PLATFORM_NAME)"
-  
+
   external_dir = File.join(__dir__, "common/cpp/audioapi/external")
-  
+
   s.ios.vendored_frameworks = [
     'common/cpp/audioapi/external/libavcodec.xcframework',
     'common/cpp/audioapi/external/libavformat.xcframework',
     'common/cpp/audioapi/external/libavutil.xcframework',
     'common/cpp/audioapi/external/libswresample.xcframework'
   ]
-  
 s.pod_target_xcconfig = {
   "USE_HEADERMAP" => "YES",
   "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
@@ -61,12 +61,15 @@ s.pod_target_xcconfig = {
   "HEADER_SEARCH_PATHS" => %W[
     $(PODS_TARGET_SRCROOT)/common/cpp
     $(PODS_TARGET_SRCROOT)/ios
+    $(PODS_ROOT)/Headers/Public/RNWorklets
+    $(PODS_ROOT)/Headers/Private/React-Core
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include/opus
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/include/vorbis
     $(PODS_TARGET_SRCROOT)/#{external_dir_relative}/ffmpeg_include
   ].join(" "),
-  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}"
+  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}",
+  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}"
 }
 
 s.user_target_xcconfig = {

package/android/build.gradle

@@ -65,6 +65,15 @@ def resolveReactNativeDirectory() {
   )
 }
 
+def resolveReactNativeWorkletsDirectory() {
+  def rnWorklets = rootProject.subprojects.find { it.name == 'react-native-worklets' }
+  if (rnWorklets != null) {
+    return rnWorklets.projectDir
+  }
+
+  return null;
+}
+
 def toPlatformFileString(String path) {
   if (Os.isFamily(Os.FAMILY_WINDOWS)) {
       path = path.replace(File.separatorChar, '/' as char)
@@ -82,6 +91,8 @@ static def supportsNamespace() {
 }
 
 def reactNativeRootDir = resolveReactNativeDirectory()
+def reactNativeWorkletsRootDir = resolveReactNativeWorkletsDirectory()
+def isWorkletsAvailable = reactNativeWorkletsRootDir != null
 
 def reactProperties = new Properties()
 file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
@@ -112,17 +123,30 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    buildConfigField "boolean", "RN_AUDIO_API_ENABLE_WORKLETS", "${isWorkletsAvailable}"
+
+
 
     externalNativeBuild {
       cmake {
         abiFilters (*reactNativeArchitectures())
-        arguments "-DANDROID_STL=c++_shared",
-                  "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
-                  "-DANDROID_TOOLCHAIN=clang",
-                  "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
+
+        def cmakeArgs = [
+          "-DANDROID_STL=c++_shared",
+          "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
+          "-DANDROID_TOOLCHAIN=clang",
+          "-DREACT_NATIVE_DIR=${toPlatformFileString(reactNativeRootDir.path)}",
+          "-DRN_AUDIO_API_WORKLETS_ENABLED=${isWorkletsAvailable}",
                   "-DIS_NEW_ARCHITECTURE_ENABLED=${IS_NEW_ARCHITECTURE_ENABLED}",
                   "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        ]
+
+        if (isWorkletsAvailable) {
+          cmakeArgs << "-DREACT_NATIVE_WORKLETS_DIR=${toPlatformFileString(reactNativeWorkletsRootDir.path)}"
+        }
+        arguments = cmakeArgs
       }
     }
   }
@@ -225,8 +249,24 @@ dependencies {
   implementation 'com.facebook.fbjni:fbjni:0.6.0'
   implementation 'com.google.oboe:oboe:1.9.3'
   implementation 'androidx.media:media:1.7.0'
+
+  if (isWorkletsAvailable) {
+    implementation(rootProject.subprojects.find { it.name == 'react-native-worklets' })
+  }
 }
 
+if (isWorkletsAvailable) {
+  // Ensure worklets is built before react-native-audio-api
+  def rnWorkletsProject = rootProject.subprojects.find { it.name == 'react-native-worklets' }
+  evaluationDependsOn(rnWorkletsProject.path)
+
+  afterEvaluate {
+      tasks.getByName("buildCMakeDebug").dependsOn(rnWorkletsProject.tasks.getByName("mergeDebugNativeLibs"))
+      tasks.getByName("buildCMakeRelWithDebInfo").dependsOn(rnWorkletsProject.tasks.getByName("mergeReleaseNativeLibs"))
+  }
+}
+
+
 def assertMinimalReactNativeVersion = task assertMinimalReactNativeVersionTask {
     // If you change the minimal React Native version remember to update Compatibility Table in docs
     def minimalReactNativeVersion = 76

package/android/src/main/cpp/audioapi/CMakeLists.txt

@@ -27,6 +27,12 @@ find_package(ReactAndroid REQUIRED CONFIG)
 find_package(fbjni REQUIRED CONFIG)
 find_package(oboe REQUIRED CONFIG)
 
+if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
+  set(BUILD_TYPE "debug")
+else()
+  set(BUILD_TYPE "release")
+endif()
+
 target_include_directories(
   react-native-audio-api
   PRIVATE
@@ -48,10 +54,69 @@ set(LINK_LIBRARIES
   oboe::oboe
 )
 
+set(INCLUDE_LIBRARIES
+  "${COMMON_CPP_DIR}"
+  "${ANDROID_CPP_DIR}"
+  "${INCLUDE_DIR}"
+  "${INCLUDE_DIR}/opus"
+  "${INCLUDE_DIR}/vorbis"
+  "${REACT_NATIVE_DIR}/ReactCommon"
+  "${REACT_NATIVE_DIR}/ReactCommon/jsiexecutor"
+  "${REACT_NATIVE_DIR}/ReactAndroid/src/main/jni/react/turbomodule"
+  "${REACT_NATIVE_DIR}/ReactCommon/callinvoker"
+)
+
+if(RN_AUDIO_API_WORKLETS_ENABLED)
+  # Import the worklets library (similar to how Reanimated does it)
+  add_library(worklets SHARED IMPORTED)
+  set_target_properties(
+    worklets
+    PROPERTIES
+      IMPORTED_LOCATION
+      "${REACT_NATIVE_WORKLETS_DIR}/build/intermediates/cmake/${BUILD_TYPE}/obj/${ANDROID_ABI}/libworklets.so"
+  )
+  list(APPEND INCLUDE_LIBRARIES
+    "${REACT_NATIVE_WORKLETS_DIR}/../Common/cpp"
+    "${REACT_NATIVE_WORKLETS_DIR}/src/main/cpp"
+  )
+  list(APPEND LINK_LIBRARIES worklets)
+endif()
+
+target_include_directories(
+  react-native-audio-api
+  PRIVATE
+  ${INCLUDE_LIBRARIES}
+)
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  set(RN_VERSION_LINK_LIBRARIES
+    ReactAndroid::reactnative
+  )
+else()
+  set(RN_VERSION_LINK_LIBRARIES
+    ReactAndroid::folly_runtime
+    ReactAndroid::react_nativemodule_core
+    ReactAndroid::glog
+    ReactAndroid::reactnativejni
+  )
+endif()
+
 set(RN_VERSION_LINK_LIBRARIES
   ReactAndroid::reactnative
 )
 
+if(RN_AUDIO_API_WORKLETS_ENABLED)
+  target_compile_definitions(
+    react-native-audio-api
+    PRIVATE RN_AUDIO_API_ENABLE_WORKLETS=1
+  )
+else()
+  target_compile_definitions(
+    react-native-audio-api
+    PRIVATE RN_AUDIO_API_ENABLE_WORKLETS=0
+  )
+endif()
+
 target_link_libraries(react-native-audio-api
   ${LINK_LIBRARIES}
   ${RN_VERSION_LINK_LIBRARIES}

package/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp

@@ -6,10 +6,16 @@ using namespace facebook::jni;
 
 AudioAPIModule::AudioAPIModule(
     jni::alias_ref<AudioAPIModule::jhybridobject> &jThis,
+#if RN_AUDIO_API_ENABLE_WORKLETS
+    std::weak_ptr<WorkletsModuleProxy> weakWorkletsModuleProxy,
+#endif
     jsi::Runtime *jsiRuntime,
     const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
     : javaPart_(make_global(jThis)),
       jsiRuntime_(jsiRuntime),
+#if RN_AUDIO_API_ENABLE_WORKLETS
+      weakWorkletsModuleProxy_(weakWorkletsModuleProxy),
+#endif
       jsCallInvoker_(jsCallInvoker) {
   audioEventHandlerRegistry_ =
       std::make_shared<AudioEventHandlerRegistry>(jsiRuntime, jsCallInvoker);
@@ -17,12 +23,25 @@ AudioAPIModule::AudioAPIModule(
 
 jni::local_ref<AudioAPIModule::jhybriddata> AudioAPIModule::initHybrid(
     jni::alias_ref<jhybridobject> jThis,
+    jni::alias_ref<jni::JObject> jWorkletsModule,
     jlong jsContext,
     jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
         jsCallInvokerHolder) {
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
   auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  if (jWorkletsModule) {
+    auto castedModule =
+        jni::static_ref_cast<WorkletsModule::javaobject>(jWorkletsModule);
+    auto workletsModuleProxy = castedModule->cthis()->getWorkletsModuleProxy();
+    return makeCxxInstance(
+        jThis, workletsModuleProxy, rnRuntime, jsCallInvoker);
+  }
+  throw std::runtime_error(
+      "Worklets module is required but not provided from Java/Kotlin side");
+#else
   return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
+#endif
 }
 
 void AudioAPIModule::registerNatives() {
@@ -36,8 +55,17 @@ void AudioAPIModule::registerNatives() {
 }
 
 void AudioAPIModule::injectJSIBindings() {
+#if RN_AUDIO_API_ENABLE_WORKLETS
+  auto uiWorkletRuntime =
+      weakWorkletsModuleProxy_.lock()->getUIWorkletRuntime();
+#else
+  auto uiWorkletRuntime = nullptr;
+#endif
   AudioAPIModuleInstaller::injectJSIBindings(
-      jsiRuntime_, jsCallInvoker_, audioEventHandlerRegistry_);
+      jsiRuntime_,
+      jsCallInvoker_,
+      audioEventHandlerRegistry_,
+      uiWorkletRuntime);
 }
 
 void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(

package/android/src/main/cpp/audioapi/android/AudioAPIModule.h

@@ -7,6 +7,7 @@
 #include <fbjni/fbjni.h>
 #include <react/jni/CxxModuleWrapper.h>
 #include <react/jni/JMessageQueueThread.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 #include <memory>
 #include <utility>
 #include <unordered_map>
@@ -15,6 +16,7 @@ namespace audioapi {
 
 using namespace facebook;
 using namespace react;
+using namespace worklets;
 
 class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
  public:
@@ -23,6 +25,7 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
 
   static jni::local_ref<AudioAPIModule::jhybriddata> initHybrid(
       jni::alias_ref<jhybridobject> jThis,
+      jni::alias_ref<jni::JObject> jWorkletsModule, // it will be null if RN_AUDIO_API_ENABLE_WORKLETS is false
       jlong jsContext,
       jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
           jsCallInvokerHolder);
@@ -37,13 +40,24 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
 
   jni::global_ref<AudioAPIModule::javaobject> javaPart_;
   jsi::Runtime *jsiRuntime_;
+  #if RN_AUDIO_API_ENABLE_WORKLETS
+  std::weak_ptr<worklets::WorkletsModuleProxy> weakWorkletsModuleProxy_;
+  #endif
   std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
   std::shared_ptr<AudioEventHandlerRegistry> audioEventHandlerRegistry_;
 
+  #if RN_AUDIO_API_ENABLE_WORKLETS
   explicit AudioAPIModule(
       jni::alias_ref<AudioAPIModule::jhybridobject> &jThis,
+      std::weak_ptr<worklets::WorkletsModuleProxy> weakWorkletsModuleProxy,
       jsi::Runtime *jsiRuntime,
       const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
+  #else
+  explicit AudioAPIModule(
+      jni::alias_ref<AudioAPIModule::jhybridobject> &jThis,
+      jsi::Runtime *jsiRuntime,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
+  #endif
 };
 
 } // namespace audioapi

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

@@ -1,6 +1,6 @@
 #include <audioapi/android/core/AndroidAudioRecorder.h>
-#include <audioapi/core/Constants.h>
 #include <audioapi/core/sources/RecorderAdapterNode.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
@@ -25,9 +25,13 @@ AndroidAudioRecorder::AndroidAudioRecorder(
       ->setDataCallback(this)
       ->setSampleRate(static_cast<int>(sampleRate))
       ->openStream(mStream_);
+
+  nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
 }
 
 AndroidAudioRecorder::~AndroidAudioRecorder() {
+  nativeAudioRecorder_.release();
+
   if (mStream_) {
     mStream_->requestStop();
     mStream_->close();
@@ -41,6 +45,7 @@ void AndroidAudioRecorder::start() {
   }
 
   if (mStream_) {
+    nativeAudioRecorder_->start();
     mStream_->requestStart();
   }
 
@@ -55,6 +60,7 @@ void AndroidAudioRecorder::stop() {
   isRunning_.store(false);
 
   if (mStream_) {
+    nativeAudioRecorder_->stop();
     mStream_->requestStop();
   }
 

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

@@ -6,6 +6,8 @@
 #include <functional>
 #include <memory>
 
+#include <audioapi/android/core/NativeAudioRecorder.hpp>
+
 namespace audioapi {
 
 using namespace oboe;
@@ -16,7 +18,8 @@ class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorde
  public:
     AndroidAudioRecorder(float sampleRate,
                          int bufferLength,
-                         const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+                         const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
+                        );
 
     ~AndroidAudioRecorder() override;
 
@@ -30,6 +33,8 @@ class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorde
 
  private:
     std::shared_ptr<AudioStream> mStream_;
+
+    facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
 };
 
 } // namespace audioapi

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

@@ -1,7 +1,7 @@
 #include <android/log.h>
 #include <audioapi/android/core/AudioPlayer.h>
 #include <audioapi/core/AudioContext.h>
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
 

package/android/src/main/cpp/audioapi/android/core/NativeAudioRecorder.hpp

@@ -0,0 +1,36 @@
+#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 NativeAudioRecorder : public jni::JavaClass<NativeAudioRecorder> {
+ public:
+  static auto constexpr kJavaDescriptor =
+            "Lcom/swmansion/audioapi/core/NativeAudioRecorder;";
+
+  static jni::local_ref<NativeAudioRecorder> create() {
+    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());
+    }
+};
+
+} // namespace audioapi

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

@@ -26,6 +26,7 @@ class AudioAPIModule(
   private val mHybridData: HybridData
 
   external fun initHybrid(
+    workletsModule: Any?,
     jsContext: Long,
     callInvoker: CallInvokerHolderImpl,
   ): HybridData
@@ -41,7 +42,16 @@ class AudioAPIModule(
     try {
       System.loadLibrary("react-native-audio-api")
       val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
-      mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
+
+      var workletsModule: Any? = null
+      if (BuildConfig.RN_AUDIO_API_ENABLE_WORKLETS) {
+        try {
+          workletsModule = reactContext.getNativeModule("WorkletsModule")
+        } catch (ex: Exception) {
+          throw RuntimeException("WorkletsModule not found - make sure react-native-worklets is properly installed")
+        }
+      }
+      mHybridData = initHybrid(workletsModule, reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
     } catch (exception: UnsatisfiedLinkError) {
       throw RuntimeException("Could not load native module AudioAPIModule", exception)
     }

package/android/src/main/java/com/swmansion/audioapi/core/NativeAudioRecorder.kt

@@ -0,0 +1,24 @@
+package com.swmansion.audioapi.core
+
+import com.facebook.common.internal.DoNotStrip
+import com.swmansion.audioapi.system.MediaSessionManager
+
+@DoNotStrip
+class NativeAudioRecorder {
+  private var inputNodeId: String? = null
+
+  @DoNotStrip
+  fun start() {
+    this.inputNodeId = MediaSessionManager.attachAudioRecorder(this)
+    MediaSessionManager.startForegroundServiceIfNecessary()
+  }
+
+  @DoNotStrip
+  fun stop() {
+    this.inputNodeId?.let {
+      MediaSessionManager.detachAudioRecorder(it)
+      this.inputNodeId = null
+    }
+    MediaSessionManager.stopForegroundServiceIfNecessary()
+  }
+}

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

@@ -21,6 +21,7 @@ import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 import com.swmansion.audioapi.AudioAPIModule
 import com.swmansion.audioapi.core.NativeAudioPlayer
+import com.swmansion.audioapi.core.NativeAudioRecorder
 import com.swmansion.audioapi.system.PermissionRequestListener.Companion.RECORDING_REQUEST_CODE
 import java.lang.ref.WeakReference
 import java.util.UUID
@@ -42,6 +43,7 @@ object MediaSessionManager {
   private var isServiceRunning = false
   private val serviceStateLock = Any()
   private val nativeAudioPlayers = mutableMapOf<String, NativeAudioPlayer>()
+  private val nativeAudioRecorders = mutableMapOf<String, NativeAudioRecorder>()
 
   fun initialize(
     audioAPIModule: WeakReference<AudioAPIModule>,
@@ -95,14 +97,25 @@ object MediaSessionManager {
     nativeAudioPlayers.remove(uuid)
   }
 
+  fun attachAudioRecorder(recorder: NativeAudioRecorder): String {
+    val uuid = UUID.randomUUID().toString()
+    nativeAudioRecorders[uuid] = recorder
+
+    return uuid
+  }
+
+  fun detachAudioRecorder(uuid: String) {
+    nativeAudioRecorders.remove(uuid)
+  }
+
   fun startForegroundServiceIfNecessary() {
-    if (nativeAudioPlayers.isNotEmpty()) {
+    if (nativeAudioPlayers.isNotEmpty() || nativeAudioRecorders.isNotEmpty()) {
       startForegroundService()
     }
   }
 
   fun stopForegroundServiceIfNecessary() {
-    if (nativeAudioPlayers.isEmpty()) {
+    if (nativeAudioPlayers.isEmpty() && nativeAudioRecorders.isEmpty()) {
       stopForegroundService()
     }
   }

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -6,10 +6,12 @@
 #include <audioapi/core/inputs/AudioRecorder.h>
 #include <audioapi/HostObjects/AudioContextHostObject.h>
 #include <audioapi/HostObjects/OfflineAudioContextHostObject.h>
-#include <audioapi/HostObjects/AudioRecorderHostObject.h>
+#include <audioapi/HostObjects/inputs/AudioRecorderHostObject.h>
 
 #include <audioapi/events/AudioEventHandlerRegistry.h>
-#include <audioapi/events/AudioEventHandlerRegistryHostObject.h>
+#include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
+
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
 
@@ -19,10 +21,16 @@ using namespace facebook;
 
 class AudioAPIModuleInstaller {
  public:
-  static void injectJSIBindings(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
-    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
+  static void injectJSIBindings(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    std::shared_ptr<worklets::WorkletRuntime> uiRuntime = nullptr) {
+    auto workletRunner = std::make_shared<UiWorkletsRunner>(uiRuntime);
+
+    auto createAudioContext = getCreateAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, workletRunner);
     auto createAudioRecorder = getCreateAudioRecorderFunction(jsiRuntime, audioEventHandlerRegistry);
-    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry);
+    auto createOfflineAudioContext = getCreateOfflineAudioContextFunction(jsiRuntime, jsCallInvoker, audioEventHandlerRegistry, workletRunner);
 
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioContext", createAudioContext);
     jsiRuntime->global().setProperty(*jsiRuntime, "createAudioRecorder", createAudioRecorder);
@@ -33,12 +41,16 @@ class AudioAPIModuleInstaller {
   }
 
  private:
-  static jsi::Function getCreateAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateAudioContextFunction(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<UiWorkletsRunner> &workletRunner) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry](
+        [jsCallInvoker, audioEventHandlerRegistry, workletRunner](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -46,7 +58,7 @@ class AudioAPIModuleInstaller {
           std::shared_ptr<AudioContext> audioContext;
           auto sampleRate = static_cast<float>(args[0].getNumber());
           auto initSuspended = args[1].getBool();
-          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry);
+          audioContext = std::make_shared<AudioContext>(sampleRate, initSuspended, audioEventHandlerRegistry, workletRunner);
 
           auto audioContextHostObject = std::make_shared<AudioContextHostObject>(
               audioContext, &runtime, jsCallInvoker);
@@ -56,12 +68,16 @@ class AudioAPIModuleInstaller {
         });
   }
 
-  static jsi::Function getCreateOfflineAudioContextFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<react::CallInvoker> &jsCallInvoker, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateOfflineAudioContextFunction(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<react::CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry,
+    const std::shared_ptr<UiWorkletsRunner> &workletRunner) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createOfflineAudioContext"),
         0,
-        [jsCallInvoker, audioEventHandlerRegistry](
+        [jsCallInvoker, audioEventHandlerRegistry, workletRunner](
             jsi::Runtime &runtime,
             const jsi::Value &thisValue,
             const jsi::Value *args,
@@ -70,7 +86,7 @@ class AudioAPIModuleInstaller {
             auto length = static_cast<size_t>(args[1].getNumber());
             auto sampleRate = static_cast<float>(args[2].getNumber());
 
-          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry);
+          auto offlineAudioContext = std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, workletRunner);
           auto audioContextHostObject = std::make_shared<OfflineAudioContextHostObject>(
               offlineAudioContext, &runtime, jsCallInvoker);
 
@@ -79,7 +95,9 @@ class AudioAPIModuleInstaller {
         });
   }
 
-  static jsi::Function getCreateAudioRecorderFunction(jsi::Runtime *jsiRuntime, const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
+  static jsi::Function getCreateAudioRecorderFunction(
+    jsi::Runtime *jsiRuntime,
+    const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry) {
     return jsi::Function::createFromHostFunction(
         *jsiRuntime,
         jsi::PropNameID::forAscii(*jsiRuntime, "createAudioRecorder"),
@@ -94,7 +112,7 @@ class AudioAPIModuleInstaller {
           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, audioEventHandlerRegistry, sampleRate, bufferLength);
+          auto audioRecorderHostObject = std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry, sampleRate, bufferLength);
 
           return jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
         });