react-native-audio-api 0.11.0-nightly-95f9c99-20251215 → 0.11.0-nightly-dd83923-20251216

package/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -10,83 +10,103 @@
  * @nolint
  */
 
- package com.swmansion.audioapi;
-
- import com.facebook.proguard.annotations.DoNotStrip;
- import com.facebook.react.bridge.Promise;
- import com.facebook.react.bridge.ReactApplicationContext;
- import com.facebook.react.bridge.ReactContextBaseJavaModule;
- import com.facebook.react.bridge.ReactMethod;
- import com.facebook.react.bridge.ReadableArray;
- import com.facebook.react.bridge.ReadableMap;
- import com.facebook.react.turbomodule.core.interfaces.TurboModule;
- import javax.annotation.Nonnull;
-
- public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
-   public static final String NAME = "AudioAPIModule";
-
-   public NativeAudioAPIModuleSpec(ReactApplicationContext reactContext) {
-     super(reactContext);
-   }
-
-   @Override
-   public @Nonnull String getName() {
-     return NAME;
-   }
-
-   @ReactMethod(isBlockingSynchronousMethod = true)
-   @DoNotStrip
-   public abstract boolean install();
-
-   @ReactMethod(isBlockingSynchronousMethod = true)
-   @DoNotStrip
-   public abstract double getDevicePreferredSampleRate();
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void setAudioSessionActivity(boolean enabled, Promise promise);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void setAudioSessionOptions(String category, String mode, ReadableArray options, boolean allowHaptics);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void disableSessionManagement();
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void setLockScreenInfo(ReadableMap info);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void resetLockScreenInfo();
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void enableRemoteCommand(String name, boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void observeAudioInterruptions(boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void activelyReclaimSession(boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void observeVolumeChanges(boolean enabled);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void requestRecordingPermissions(Promise promise);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void checkRecordingPermissions(Promise promise);
-
-   @ReactMethod
-   @DoNotStrip
-   public abstract void getDevicesInfo(Promise promise);
- }
+package com.swmansion.audioapi;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.turbomodule.core.interfaces.TurboModule;
+import javax.annotation.Nonnull;
+
+public abstract class NativeAudioAPIModuleSpec extends ReactContextBaseJavaModule implements TurboModule {
+  public static final String NAME = "AudioAPIModule";
+
+  public NativeAudioAPIModuleSpec(ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @Override
+  public @Nonnull String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract boolean install();
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  @DoNotStrip
+  public abstract double getDevicePreferredSampleRate();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setAudioSessionActivity(boolean enabled, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void setAudioSessionOptions(String category, String mode, ReadableArray options, boolean allowHaptics);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void disableSessionManagement();
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void observeAudioInterruptions(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void activelyReclaimSession(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void observeVolumeChanges(boolean enabled);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void requestRecordingPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void checkRecordingPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void requestNotificationPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void checkNotificationPermissions(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getDevicesInfo(Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void registerNotification(String type, String key, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void showNotification(String key, ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void updateNotification(String key, ReadableMap options, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void hideNotification(String key, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void unregisterNotification(String key, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void isNotificationActive(String key, Promise promise);
+}

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -16,6 +16,7 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace audioapi {
@@ -137,19 +138,10 @@ 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);
+          auto audioRecorderHostObject =
+              std::make_shared<AudioRecorderHostObject>(audioEventHandlerRegistry);
 
           auto jsiObject = jsi::Object::createFromHostObject(runtime, audioRecorderHostObject);
-          jsiObject.setExternalMemoryPressure(
-              runtime, sizeof(float) * bufferLength); // rough estimate of underlying buffer
 
           return jsiObject;
         });

package/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
@@ -15,33 +16,121 @@
 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.is_ok() ? "success" : "error"));
+
+  if (result.is_ok()) {
+    jsResult.setProperty(runtime, "path", jsi::String::createFromUtf8(runtime, result.unwrap()));
+  } else {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  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.is_ok() ? "success" : "error"));
+
+  if (result.is_ok()) {
+    auto info = result.unwrap();
+
+    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.unwrap_err()));
+  }
+
+  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_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.is_ok() ? "success" : "error"));
+
+  if (result.is_ok()) {
+    jsResult.setProperty(runtime, "path", jsi::String::createFromUtf8(runtime, result.unwrap()));
+  } else {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  return jsResult;
 }
 
-JSI_PROPERTY_SETTER_IMPL(AudioRecorderHostObject, onAudioReady) {
-  audioRecorder_->setOnAudioReadyCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+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_));
   return jsi::Value::undefined();
@@ -49,19 +138,59 @@ 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<int>(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.is_ok() ? "success" : "error"));
+
+  if (result.is_err()) {
+    jsResult.setProperty(
+        runtime, "message", jsi::String::createFromUtf8(runtime, result.unwrap_err()));
+  }
+
+  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

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

@@ -4,6 +4,7 @@
 
 #include <cstdio>
 #include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 
@@ -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

package/common/cpp/audioapi/core/inputs/AudioRecorder.cpp

@@ -1,83 +1,66 @@
-#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>
-#include <algorithm>
-#include <memory>
-#include <string>
-#include <unordered_map>
+#include <audioapi/core/utils/AudioFileWriter.h>
+#include <audioapi/core/utils/AudioRecorderCallback.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);
-}
+/// @brief Sets the error callback to be invoked when an error occurs during recording.
+/// This method should be called from the JS thread only.
+/// @param callbackId Identifier for the JS callback to be invoked.
+void AudioRecorder::setOnErrorCallback(uint64_t callbackId) {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
+
+  if (usesFileOutput()) {
+    fileWriter_->setOnErrorCallback(callbackId);
+  }
+
+  if (usesCallback()) {
+    dataCallback_->setOnErrorCallback(callbackId);
+  }
 
-void AudioRecorder::setOnAudioReadyCallbackId(uint64_t callbackId) {
-  onAudioReadyCallbackId_ = callbackId;
+  errorCallbackId_.store(callbackId, std::memory_order_release);
 }
 
-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);
+/// @brief Clears the error callback.
+/// If the recorder is currently active, it will stop invoking the callback immediately.
+/// This method should be called from the JS thread only.
+void AudioRecorder::clearOnErrorCallback() {
+  std::scoped_lock lock(callbackMutex_, fileWriterMutex_, errorCallbackMutex_);
 
-  std::unordered_map<std::string, EventValue> body = {};
-  body.insert({"buffer", audioBufferHostObject});
-  body.insert({"numFrames", numFrames});
+  if (usesFileOutput()) {
+    fileWriter_->clearOnErrorCallback();
+  }
 
-  if (audioEventHandlerRegistry_ != nullptr) {
-    audioEventHandlerRegistry_->invokeHandlerWithEventBody(
-        "audioReady", onAudioReadyCallbackId_, body);
+  if (usesCallback()) {
+    dataCallback_->clearOnErrorCallback();
   }
+
+  errorCallbackId_.store(0, std::memory_order_release);
 }
 
-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());
+/// @brief Gets the current duration of the recorded audio in seconds.
+/// @returns Duration in seconds.
+double AudioRecorder::getCurrentDuration() const {
+  double duration = 0.0;
 
-  circularBuffer_->pop_front(outputChannel, circularBuffer_->getNumberOfAvailableFrames());
+  if (usesFileOutput()) {
+    duration = fileWriter_->getCurrentDuration();
+  }
 
-  invokeOnAudioReadyCallback(bus, availableFrames);
+  return duration;
 }
 
-void AudioRecorder::connect(const std::shared_ptr<RecorderAdapterNode> &node) {
-  node->init(ringBufferSize_);
-  adapterNodeLock_.lock();
-  adapterNode_ = node;
-  adapterNodeLock_.unlock();
+bool AudioRecorder::usesCallback() const {
+  return callbackOutputEnabled_.load(std::memory_order_acquire);
 }
 
-void AudioRecorder::disconnect() {
-  adapterNodeLock_.lock();
-  adapterNode_ = nullptr;
-  adapterNodeLock_.unlock();
+bool AudioRecorder::usesFileOutput() const {
+  return fileOutputEnabled_.load(std::memory_order_acquire);
 }
 
-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);
+bool AudioRecorder::isConnected() const {
+  return isConnected_.load(std::memory_order_acquire);
 }
 
 } // namespace audioapi