react-native-audio-api 0.10.0-nightly-e16d7ff-20251030 → 0.11.0-alpha.1

package/RNAudioAPI.podspec

@@ -1,5 +1,4 @@
 require "json"
-require_relative './scripts/rnaa_utils'
 
 package_json = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
@@ -9,8 +8,6 @@ folly_flags = "-DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-
 fabric_flags = $new_arch_enabled ? '-DRCT_NEW_ARCH_ENABLED' : ''
 version_flag = "-DAUDIOAPI_VERSION=#{package_json['version']}"
 
-worklets_preprocessor_flag = check_if_worklets_enabled() ? '-DRN_AUDIO_API_ENABLE_WORKLETS=1' : ''
-
 Pod::Spec.new do |s|
   s.name         = "RNAudioAPI"
   s.version      = package_json["version"]
@@ -32,23 +29,15 @@ Pod::Spec.new do |s|
       sss.header_dir = "audioapi"
       sss.header_mappings_dir = "ios/audioapi"
     end
-
-    ss.subspec "audioapi_dsp" do |sss|
-      sss.source_files = "common/cpp/audioapi/dsp/**/*.{cpp}"
-      sss.header_dir = "audioapi/dsp"
-      sss.header_mappings_dir = "common/cpp/audioapi/dsp"
-      sss.compiler_flags = "-O3"
-    end
   end
 
   s.ios.frameworks = 'CoreFoundation', 'CoreAudio', 'AudioToolbox', 'Accelerate', 'MediaPlayer', 'AVFoundation'
 
   s.compiler_flags = "#{folly_flags}"
 
-  s.prepare_command = <<-CMD
-    chmod +x scripts/download-prebuilt-binaries.sh
-    scripts/download-prebuilt-binaries.sh ios
-  CMD
+  # s.prepare_command = <<-CMD TODO: re-add when we have prebuilt libs put somewhere public
+  #   ruby -r './scripts/download-audioapi-libs.rb'
+  # CMD
 
   # Assumes Pods dir is nested under ios project dir
   ios_dir = File.join(Pod::Config.instance.project_pods_root, '..')
@@ -57,6 +46,8 @@ Pod::Spec.new do |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',
@@ -77,8 +68,8 @@ s.pod_target_xcconfig = {
     $(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} #{worklets_preprocessor_flag}",
-  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag} #{worklets_preprocessor_flag}",
+  'OTHER_CFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}",
+  'OTHER_CPLUSPLUSFLAGS' => "$(inherited) #{folly_flags} #{fabric_flags} #{version_flag}"
 }
 
 s.user_target_xcconfig = {
@@ -97,6 +88,10 @@ s.user_target_xcconfig = {
     $(inherited)
     $(PODS_ROOT)/Headers/Public/RNAudioAPI
     $(PODS_TARGET_SRCROOT)/common/cpp
+    #{external_dir}/include
+    #{external_dir}/include/opus
+    #{external_dir}/include/vorbis
+    #{external_dir}/ffmpeg_include
   ].join(' ')
 }
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.

package/android/build.gradle

@@ -74,30 +74,6 @@ def resolveReactNativeWorkletsDirectory() {
   return null;
 }
 
-def validateWorkletsVersion() {
-  def validationScript = file("${projectDir}/../scripts/validate-worklets-version.js")
-  if (!validationScript.exists()) {
-    logger.error("[AudioAPI] Worklets validation script not found at ${validationScript.absolutePath}")
-    return false
-  }
-
-  try {
-    def process = ["node", validationScript.absolutePath].execute()
-    process.waitForProcessOutput(System.out, System.err)
-    def exitCode = process.exitValue()
-
-    if (exitCode == 0) {
-      return true
-    } else {
-      logger.warn("[AudioAPI] Worklets version validation failed")
-      return false
-    }
-  } catch (Exception e) {
-    logger.error("[AudioAPI] Failed to validate worklets version: ${e.message}")
-    return false
-  }
-}
-
 def toPlatformFileString(String path) {
   if (Os.isFamily(Os.FAMILY_WINDOWS)) {
       path = path.replace(File.separatorChar, '/' as char)
@@ -116,7 +92,7 @@ static def supportsNamespace() {
 
 def reactNativeRootDir = resolveReactNativeDirectory()
 def reactNativeWorkletsRootDir = resolveReactNativeWorkletsDirectory()
-def isWorkletsAvailable = reactNativeWorkletsRootDir != null && validateWorkletsVersion()
+def isWorkletsAvailable = reactNativeWorkletsRootDir != null
 
 def reactProperties = new Properties()
 file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
@@ -147,7 +123,7 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-
+    
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     buildConfigField "boolean", "RN_AUDIO_API_ENABLE_WORKLETS", "${isWorkletsAvailable}"
 
@@ -301,16 +277,10 @@ def assertMinimalReactNativeVersion = task assertMinimalReactNativeVersionTask {
     }
 }
 
-task downloadPrebuiltBinaries(type: Exec) {
-  commandLine 'chmod', '+x', '../scripts/download-prebuilt-binaries.sh'
-  commandLine 'bash', '../scripts/download-prebuilt-binaries.sh'
-  args 'android'
-}
-
 // Make preBuild depend on the download task
 tasks.preBuild {
     dependsOn assertMinimalReactNativeVersion
-    dependsOn downloadPrebuiltBinaries
+    // dependsOn downloadStaticPrebuiltLibraries TODO: re-add when we have prebuilt libs put somewhere public
 }
 
 task cleanCmakeCache() {

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

@@ -3,12 +3,6 @@ cmake_minimum_required(VERSION 3.12.0)
 file(GLOB_RECURSE ANDROID_CPP_SOURCES CONFIGURE_DEPENDS "${ANDROID_CPP_DIR}/audioapi/*.cpp")
 file(GLOB_RECURSE COMMON_CPP_SOURCES CONFIGURE_DEPENDS "${COMMON_CPP_DIR}/audioapi/*.cpp" "${COMMON_CPP_DIR}/audioapi/*.c")
 
-set_source_files_properties(
-  ${COMMON_CPP_SOURCES}/dsp/*.cpp
-  PROPERTIES
-  COMPILE_FLAGS "-O3"
-)
-
 set(INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/include)
 set(FFMPEG_INCLUDE_DIR ${COMMON_CPP_DIR}/audioapi/external/ffmpeg_include)
 set(EXTERNAL_DIR ${COMMON_CPP_DIR}/audioapi/external)

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

@@ -51,7 +51,6 @@ void AudioAPIModule::registerNatives() {
       makeNativeMethod(
           "invokeHandlerWithEventNameAndEventBody",
           AudioAPIModule::invokeHandlerWithEventNameAndEventBody),
-      makeNativeMethod("closeAllContexts", AudioAPIModule::closeAllContexts),
   });
 }
 
@@ -102,8 +101,4 @@ void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
         eventName->toStdString(), body);
   }
 }
-
-void AudioAPIModule::closeAllContexts() {
-  AudioAPIModuleInstaller::closeAllContexts();
-}
 } // namespace audioapi

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

@@ -34,7 +34,6 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
 
   void injectJSIBindings();
   void invokeHandlerWithEventNameAndEventBody(jni::alias_ref<jni::JString> eventName, jni::alias_ref<jni::JMap<jstring, jobject>> eventBody);
-  void closeAllContexts();
 
  private:
   friend HybridBase;

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

@@ -1,4 +1,9 @@
+#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/events/AudioEventHandlerRegistry.h>
@@ -10,22 +15,22 @@
 namespace audioapi {
 
 AndroidAudioRecorder::AndroidAudioRecorder(
-    float sampleRate,
-    int bufferLength,
     const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry)
-    : AudioRecorder(sampleRate, bufferLength, audioEventHandlerRegistry) {
+    : AudioRecorder(audioEventHandlerRegistry) {
   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_);
 
+  streamSampleRate_ = mStream_->getSampleRate();
+  streamChannelCount_ = mStream_->getChannelCount();
+  streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
   nativeAudioRecorder_ = jni::make_global(NativeAudioRecorder::create());
 }
 
@@ -39,53 +44,162 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
   }
 }
 
-void AndroidAudioRecorder::start() {
-  if (isRunning_.load()) {
-    return;
+std::string AndroidAudioRecorder::start() {
+  if (isRecording()) {
+    return filePath_;
   }
 
-  if (mStream_) {
-    nativeAudioRecorder_->start();
-    mStream_->requestStart();
+  if (!mStream_ || !nativeAudioRecorder_) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AndroidAudioRecorder",
+        "Audio stream is not initialized.\n");
+    return filePath_;
+  }
+
+  if (usesFileOutput()) {
+    filePath_ = fileWriter_->openFile(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+  }
+
+  if (usesCallback()) {
+    // TODO: create circular buffer and converter?
+    callback_->prepare(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+  }
+
+  if (isConnected()) {
+    // TODO: set adapter node properties?
+  }
+
+  nativeAudioRecorder_->start();
+  mStream_->requestStart();
+  state_.store(RecorderState::Recording);
+
+  return filePath_;
+}
+
+std::tuple<std::string, double, double> AndroidAudioRecorder::stop() {
+  std::string filePath = filePath_;
+  double outputFileSize = 0.0;
+  double outputDuration = 0.0;
+
+  if (!isRecording()) {
+    return {filePath_, 0.0, 0.0};
+  }
+
+  if (!mStream_ || !nativeAudioRecorder_) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AndroidAudioRecorder",
+        "Audio stream is not initialized.\n");
+    return {filePath_, 0.0, 0.0};
+  }
+
+  nativeAudioRecorder_->stop();
+  mStream_->requestStop();
+  state_.store(RecorderState::Idle);
+
+  if (usesFileOutput()) {
+    auto [size, duration] = fileWriter_->closeFile();
+    outputFileSize = size;
+    outputDuration = duration;
+  }
+
+  if (usesCallback()) {
+    callback_->cleanup();
   }
 
-  isRunning_.store(true);
+  filePath_ = "";
+  return {filePath, outputFileSize, outputDuration};
 }
 
-void AndroidAudioRecorder::stop() {
-  if (!isRunning_.load()) {
+void AndroidAudioRecorder::enableFileOutput(
+    float sampleRate,
+    size_t channelCount,
+    size_t bitRate,
+    size_t iosFlags,
+    size_t androidFlags) {
+  uint8_t format = static_cast<uint8_t>(androidFlags & 0xF);
+
+  if (format == 1) {
+    fileWriter_ = std::make_shared<MiniAudioFileWriter>(
+        sampleRate, channelCount, bitRate, androidFlags);
+  } else {
+    fileWriter_ = std::make_shared<FFmpegAudioFileWriter>(
+        sampleRate, channelCount, bitRate, androidFlags);
+  }
+
+  fileOutputEnabled_.store(true);
+}
+
+void AndroidAudioRecorder::disableFileOutput() {
+  fileOutputEnabled_.store(false);
+  fileWriter_ = nullptr;
+}
+
+void AndroidAudioRecorder::pause() {
+  if (!isRecording()) {
     return;
   }
 
-  isRunning_.store(false);
+  mStream_->pause(0);
+  state_.store(RecorderState::Paused);
+}
 
-  if (mStream_) {
-    nativeAudioRecorder_->stop();
-    mStream_->requestStop();
+void AndroidAudioRecorder::resume() {
+  if (!isPaused()) {
+    return;
   }
 
-  sendRemainingData();
+  mStream_->start(0);
+  state_.store(RecorderState::Recording);
+}
+
+void AndroidAudioRecorder::setOnAudioReadyCallback(
+    float sampleRate,
+    size_t bufferLength,
+    size_t channelCount,
+    uint64_t callbackId) {
+  callback_ = std::make_shared<AndroidRecorderCallback>(
+      audioEventHandlerRegistry_,
+      sampleRate,
+      bufferLength,
+      channelCount,
+      callbackId);
+  callbackOutputEnabled_.store(true);
+}
+
+void AndroidAudioRecorder::clearOnAudioReadyCallback() {
+  callbackOutputEnabled_.store(false);
+  callback_ = nullptr;
 }
 
 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()) {
+    fileWriter_->writeAudioData(audioData, numFrames);
+  }
 
-    invokeOnAudioReadyCallback(bus, bufferLength_);
+  if (usesCallback()) {
+    callback_->receiveAudioData(audioData, numFrames);
   }
 
   return DataCallbackResult::Continue;
 }
 
+double AndroidAudioRecorder::getCurrentDuration() const {
+  if (usesFileOutput()) {
+    return fileWriter_->getCurrentDuration();
+  }
+
+  return 0.0;
+}
+
 } // namespace audioapi

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

@@ -5,6 +5,8 @@
 #include <oboe/Oboe.h>
 #include <functional>
 #include <memory>
+#include <string>
+#include <tuple>
 
 #include <audioapi/android/core/NativeAudioRecorder.hpp>
 
@@ -13,28 +15,53 @@ namespace audioapi {
 using namespace oboe;
 
 class AudioBus;
+class CircularAudioArray;
+class AndroidRecorderCallback;
+class AndroidFileWriterBackend;
+class AudioEventHandlerRegistry;
 
 class AndroidAudioRecorder : public AudioStreamDataCallback, public AudioRecorder {
  public:
-    AndroidAudioRecorder(float sampleRate,
-                         int bufferLength,
-                         const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry
-                        );
+  explicit AndroidAudioRecorder(const std::shared_ptr<AudioEventHandlerRegistry> &audioEventHandlerRegistry);
+  ~AndroidAudioRecorder() override;
 
-    ~AndroidAudioRecorder() override;
+  std::string start() override;
+  std::tuple<std::string, double, double> stop() override;
 
-    void start() override;
-    void stop() override;
+  void enableFileOutput(
+      float sampleRate,
+      size_t channelCount,
+      size_t bitRate,
+      size_t iosFlags,
+      size_t androidFlags) override;
+  void disableFileOutput() override;
 
-    DataCallbackResult onAudioReady(
-            AudioStream *oboeStream,
-            void *audioData,
-            int32_t numFrames) override;
+  void pause() override;
+  void resume() override;
+
+  void setOnAudioReadyCallback(float sampleRate, size_t bufferLength, size_t channelCount, uint64_t callbackId)
+      override;
+  void clearOnAudioReadyCallback() override;
+
+  double getCurrentDuration() const override;
+
+  DataCallbackResult onAudioReady(
+          AudioStream *oboeStream,
+          void *audioData,
+          int32_t numFrames) override;
 
  private:
-    std::shared_ptr<AudioStream> mStream_;
+  std::string filePath_;
+  std::shared_ptr<AudioStream> mStream_;
+
+  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_;
 };
 
 } // namespace audioapi

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

@@ -4,7 +4,6 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/utils/AudioArray.h>
 #include <audioapi/utils/AudioBus.h>
-#include <jni.h>
 
 namespace audioapi {
 
@@ -50,8 +49,7 @@ bool AudioPlayer::openAudioStream() {
 
 bool AudioPlayer::start() {
   if (mStream_) {
-    jni::ThreadScope::WithClassLoader(
-        [this]() { nativeAudioPlayer_->start(); });
+    nativeAudioPlayer_->start();
     auto result = mStream_->requestStart();
     return result == oboe::Result::OK;
   }
@@ -61,7 +59,7 @@ bool AudioPlayer::start() {
 
 void AudioPlayer::stop() {
   if (mStream_) {
-    jni::ThreadScope::WithClassLoader([this]() { nativeAudioPlayer_->stop(); });
+    nativeAudioPlayer_->stop();
     mStream_->requestStop();
   }
 }

package/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

package/android/src/main/cpp/audioapi/android/core/utils/AndroidFileWriterBackend.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <tuple>
+#include <string>
+#include <memory>
+
+namespace audioapi {
+
+class AndroidFileWriterBackend {
+ public:
+  AndroidFileWriterBackend(
+    float sampleRate,
+    size_t channelCount,
+    size_t bitRate,
+    size_t androidFlags) {}
+
+  virtual ~AndroidFileWriterBackend() = default;
+
+  virtual std::string openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
+  virtual std::tuple<double, double> 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::string filePath_{""};
+  std::atomic<size_t> framesWritten_{0};
+
+  int32_t streamSampleRate_{0};
+  int32_t streamChannelCount_{0};
+  int32_t streamMaxBufferSize_{0};
+};
+
+} // namespace audioapi