react-native-audio-api 0.10.0-nightly-c815c40-20251026 → 0.11.0-alpha.0

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"]
@@ -38,10 +35,9 @@ Pod::Spec.new do |s|
 
   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, '..')
@@ -72,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 = {

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/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,8 @@
+#include <android/log.h>
 #include <audioapi/android/core/AndroidAudioRecorder.h>
+#include <audioapi/android/core/utils/AndroidFileWriterBackend.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 +14,23 @@
 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());
 }
 
@@ -40,52 +45,113 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
 }
 
 void AndroidAudioRecorder::start() {
-  if (isRunning_.load()) {
+  if (isRecording()) {
     return;
   }
 
-  if (mStream_) {
-    nativeAudioRecorder_->start();
-    mStream_->requestStart();
+  if (!mStream_ || !nativeAudioRecorder_) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AndroidAudioRecorder",
+        "Audio stream is not initialized.\n");
+    return;
+  }
+
+  if (usesFileOutput()) {
+    fileWriter_->openFile(
+        streamSampleRate_, streamChannelCount_, streamMaxBufferSizeInFrames_);
+  }
+
+  if (usesCallback()) {
+    // TODO: create circular buffer and converter?
   }
 
+  if (isConnected()) {
+    // TODO: set adapter node properties?
+  }
+
+  nativeAudioRecorder_->start();
+  mStream_->requestStart();
   isRunning_.store(true);
 }
 
-void AndroidAudioRecorder::stop() {
-  if (!isRunning_.load()) {
-    return;
+std::string AndroidAudioRecorder::stop() {
+  if (!isRecording()) {
+    return "";
+  }
+
+  if (!mStream_ || !nativeAudioRecorder_) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AndroidAudioRecorder",
+        "Audio stream is not initialized.\n");
+    return "";
   }
 
+  nativeAudioRecorder_->stop();
+  mStream_->requestStop();
   isRunning_.store(false);
 
-  if (mStream_) {
-    nativeAudioRecorder_->stop();
-    mStream_->requestStop();
+  // TODO: sendRemainingData() ?
+
+  if (usesFileOutput()) {
+    return fileWriter_->closeFile();
   }
 
-  sendRemainingData();
+  return "";
 }
 
-DataCallbackResult AndroidAudioRecorder::onAudioReady(
-    oboe::AudioStream *oboeStream,
-    void *audioData,
-    int32_t numFrames) {
-  if (isRunning_.load()) {
-    auto *inputChannel = static_cast<float *>(audioData);
-    writeToBuffers(inputChannel, numFrames);
+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);
   }
 
-  while (circularBuffer_->getNumberOfAvailableFrames() >= bufferLength_) {
-    auto bus = std::make_shared<AudioBus>(bufferLength_, 1, sampleRate_);
-    auto *outputChannel = bus->getChannel(0)->getData();
+  fileOutputEnabled_.store(true);
+}
+
+void AndroidAudioRecorder::disableFileOutput() {
+  fileOutputEnabled_.store(false);
+  fileWriter_ = nullptr;
+}
+
+void AndroidAudioRecorder::pause() {}
 
-    circularBuffer_->pop_front(outputChannel, bufferLength_);
+void AndroidAudioRecorder::resume() {}
 
-    invokeOnAudioReadyCallback(bus, bufferLength_);
+DataCallbackResult AndroidAudioRecorder::onAudioReady(
+    oboe::AudioStream *oboeStream,
+    void *audioData,
+    int32_t numFrames) {
+  if (usesFileOutput()) {
+    fileWriter_->writeAudioData(audioData, numFrames);
   }
 
   return DataCallbackResult::Continue;
 }
 
 } // namespace audioapi
+
+// if (isRunning_.load()) {
+//   auto *inputChannel = static_cast<float *>(audioData);
+//   writeToBuffers(inputChannel, 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_);
+// }

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

@@ -5,6 +5,7 @@
 #include <oboe/Oboe.h>
 #include <functional>
 #include <memory>
+#include <string>
 
 #include <audioapi/android/core/NativeAudioRecorder.hpp>
 
@@ -13,28 +14,41 @@ namespace audioapi {
 using namespace oboe;
 
 class AudioBus;
+class CircularAudioArray;
+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;
+  void start() override;
+  std::string 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;
 
- private:
-    std::shared_ptr<AudioStream> mStream_;
+  DataCallbackResult onAudioReady(
+          AudioStream *oboeStream,
+          void *audioData,
+          int32_t numFrames) override;
 
-    facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
+ private:
+  std::shared_ptr<AndroidFileWriterBackend> fileWriter_;
+  std::shared_ptr<AudioStream> mStream_;
+  facebook::jni::global_ref<NativeAudioRecorder> nativeAudioRecorder_;
+  int32_t streamSampleRate_;
+  int32_t streamChannelCount_;
+  int32_t streamMaxBufferSizeInFrames_;
 };
 
 } // 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,33 @@
+#pragma once
+
+#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 void openFile(int32_t streamSampleRate, int32_t streamChannelCount, int32_t streamMaxBufferSize) = 0;
+  virtual std::string closeFile() = 0;
+
+  virtual bool writeAudioData(void *data, int numFrames) = 0;
+
+  std::string getFilePath() const { return filePath_; }
+
+ protected:
+  std::string filePath_{""};
+
+  int32_t streamSampleRate_{0};
+  int32_t streamChannelCount_{0};
+  int32_t streamMaxBufferSize_{0};
+};
+
+} // namespace audioapi

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

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

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <string>
+
+namespace audioapi::android::fileutils {
+
+enum class FileDirectory {
+  FILES_DIR,
+  CACHE_DIR,
+};
+
+enum class FileFormat {
+  WAV,
+  CAF,
+  M4A,
+  FLAC,
+};
+
+enum class BitDepth {
+  BIT_16,
+  BIT_24,
+  BIT_32,
+};
+
+bool createDirectoryIfNotExists(const std::string &directoryPath);
+std::string getTimestampString();
+std::string getISODateString();
+FileFormat formatFromFlags(size_t flags);
+FileDirectory directoryFromFlags(size_t flags);
+BitDepth bitDepthFromFlags(size_t flags);
+std::string getDirectory(FileDirectory dir);
+std::string getFilePath(const FileDirectory &directory, const std::string &baseFileName, const std::string &extension);
+
+} // namespace audioapi::android::fileutils

package/android/src/main/cpp/audioapi/android/core/utils/FileUtilts.cpp

@@ -0,0 +1,133 @@
+
+#include <android/log.h>
+#include <audioapi/android/core/utils/FileUtils.h>
+#include <audioapi/android/system/NativeFileInfo.hpp>
+#include <chrono>
+#include <filesystem>
+#include <format>
+#include <iostream>
+
+namespace audioapi::android::fileutils {
+
+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,
+          "FileUtils",
+          "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,
+        "FileUtils",
+        "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 getISODateString() {
+  auto tNow = std::chrono::system_clock::now();
+  return std::format(
+      "{:%Y-%m-%d}", std::chrono::floor<std::chrono::days>(tNow));
+}
+
+FileFormat formatFromFlags(size_t flags) {
+  uint8_t formatFlag = static_cast<uint8_t>(flags & 0xF);
+
+  switch (formatFlag) {
+    case 1:
+      return FileFormat::WAV;
+    case 2:
+      return FileFormat::CAF;
+    case 3:
+      return FileFormat::M4A;
+    case 4:
+      return FileFormat::FLAC;
+    default:
+      return FileFormat::M4A;
+  }
+}
+
+FileDirectory directoryFromFlags(size_t flags) {
+  uint8_t directoryFlag = static_cast<uint8_t>((flags >> 4) & 0xF);
+
+  switch (directoryFlag) {
+    case 1:
+      return FileDirectory::FILES_DIR;
+    case 2:
+      return FileDirectory::CACHE_DIR;
+    default:
+      return FileDirectory::CACHE_DIR;
+  }
+}
+
+BitDepth bitDepthFromFlags(size_t flags) {
+  uint8_t bitDepthFlag = static_cast<uint8_t>((flags >> 8) & 0xF);
+
+  switch (bitDepthFlag) {
+    case 1:
+      return BitDepth::BIT_16;
+    case 2:
+      return BitDepth::BIT_24;
+    case 3:
+      return BitDepth::BIT_32;
+    default:
+      return BitDepth::BIT_32;
+  }
+}
+
+std::string getDirectory(FileDirectory dir) {
+  switch (dir) {
+    case FileDirectory::FILES_DIR:
+      return NativeFileInfo::getFilesDir();
+    case FileDirectory::CACHE_DIR:
+      return NativeFileInfo::getCacheDir();
+    default:
+      return NativeFileInfo::getCacheDir();
+  }
+}
+
+std::string getFilePath(
+    const FileDirectory &directory,
+    const std::string &baseFileName,
+    const std::string &extension) {
+  std::string basePath = getDirectory(directory);
+  std::string subDirectory = getISODateString();
+  std::string fileTimestamp = getTimestampString();
+
+  std::string subDirectoryPath =
+      std::format("{}/AudioAPI/{}", basePath, subDirectory);
+
+  if (!createDirectoryIfNotExists(subDirectoryPath)) {
+    return "";
+  }
+
+  return std::format(
+      "{}/{}_{}.{}", subDirectoryPath, baseFileName, fileTimestamp, extension);
+}
+
+} // namespace audioapi::android::fileutils

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