react-native-audio-api 0.12.0-nightly-0d1a19d-20260120 → 0.12.0-nightly-6993a06-20260122

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

@@ -1,5 +1,6 @@
 package com.swmansion.audioapi
 
+import android.media.AudioManager
 import androidx.annotation.RequiresPermission
 import com.facebook.jni.HybridData
 import com.facebook.react.bridge.Arguments
@@ -115,8 +116,21 @@ class AudioAPIModule(
     // nothing to do here
   }
 
-  override fun observeAudioInterruptions(enabled: Boolean) {
-    MediaSessionManager.observeAudioInterruptions(enabled)
+  override fun observeAudioInterruptions(
+    focusType: String?,
+    enabled: Boolean,
+  ) {
+    if (!enabled) {
+      MediaSessionManager.abandonAudioFocus()
+      return
+    }
+    when (focusType) {
+      "gain" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN)
+      "gainTransient" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+      "gainTransientMayDuck" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK)
+      "gainTransientExclusive" -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE)
+      else -> MediaSessionManager.requestAudioFocus(AudioManager.AUDIOFOCUS_GAIN)
+    }
   }
 
   override fun activelyReclaimSession(enabled: Boolean) {

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

@@ -47,20 +47,24 @@ class AudioFocusListener(
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
+
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("duck", emptyMap())
+      }
     }
   }
 
-  fun requestAudioFocus() {
+  fun requestAudioFocus(focus: Int) {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       this.focusRequest =
         AudioFocusRequest
-          .Builder(AudioManager.AUDIOFOCUS_GAIN)
+          .Builder(focus)
           .setOnAudioFocusChangeListener(this)
           .build()
 
       audioManager.get()?.requestAudioFocus(focusRequest!!)
     } else {
-      audioManager.get()?.requestAudioFocus(this, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
+      audioManager.get()?.requestAudioFocus(this, AudioManager.STREAM_MUSIC, focus)
     }
   }
 

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

@@ -88,12 +88,12 @@ object MediaSessionManager {
     return sampleRate.toDouble()
   }
 
-  fun observeAudioInterruptions(observe: Boolean) {
-    if (observe) {
-      audioFocusListener.requestAudioFocus()
-    } else {
-      audioFocusListener.abandonAudioFocus()
-    }
+  fun requestAudioFocus(focus: Int) {
+    audioFocusListener.requestAudioFocus(focus)
+  }
+
+  fun abandonAudioFocus() {
+    audioFocusListener.abandonAudioFocus()
   }
 
   fun activelyReclaimSession(enabled: Boolean) {

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -22,7 +22,9 @@
 #include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 
+#include <audioapi/HostObjects/utils/NodeOptionsParser.h>
 #include <memory>
+#include <utility>
 #include <vector>
 
 namespace audioapi {
@@ -165,14 +167,21 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
-  auto oscillator = context_->createOscillator();
+  const auto options = args[0].asObject(runtime);
+  const auto oscillatorOptions = audioapi::option_parser::parseOscillatorOptions(runtime, options);
+  auto oscillator = context_->createOscillator(oscillatorOptions);
   auto oscillatorHostObject = std::make_shared<OscillatorNodeHostObject>(oscillator);
   return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
 #if !RN_AUDIO_API_FFMPEG_DISABLED
-  auto streamer = context_->createStreamer();
+  auto streamerOptions = StreamerOptions();
+  if (!args[0].isUndefined()) {
+    const auto options = args[0].asObject(runtime);
+    streamerOptions = audioapi::option_parser::parseStreamerOptions(runtime, options);
+  }
+  auto streamer = context_->createStreamer(streamerOptions);
   auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(streamer);
   auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
   object.setExternalMemoryPressure(runtime, StreamerNodeHostObject::getSizeInBytes());
@@ -183,20 +192,26 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
-  auto constantSource = context_->createConstantSource();
+  const auto options = args[0].asObject(runtime);
+  const auto constantSourceOptions =
+      audioapi::option_parser::parseConstantSourceOptions(runtime, options);
+  auto constantSource = context_->createConstantSource(constantSourceOptions);
   auto constantSourceHostObject = std::make_shared<ConstantSourceNodeHostObject>(constantSource);
   return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
-  auto gain = context_->createGain();
+  const auto options = args[0].asObject(runtime);
+  const auto gainOptions = audioapi::option_parser::parseGainOptions(runtime, options);
+  auto gain = context_->createGain(std::move(gainOptions));
   auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
   return jsi::Object::createFromHostObject(runtime, gainHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
-  auto maxDelayTime = static_cast<float>(args[0].getNumber());
-  auto delayNode = context_->createDelay(maxDelayTime);
+  const auto options = args[0].asObject(runtime);
+  const auto delayOptions = audioapi::option_parser::parseDelayOptions(runtime, options);
+  auto delayNode = context_->createDelay(delayOptions);
   auto delayNodeHostObject = std::make_shared<DelayNodeHostObject>(delayNode);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, delayNodeHostObject);
   jsiObject.setExternalMemoryPressure(runtime, delayNodeHostObject->getSizeInBytes());
@@ -204,63 +219,52 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
-  auto stereoPanner = context_->createStereoPanner();
+  const auto options = args[0].asObject(runtime);
+  const auto stereoPannerOptions = audioapi::option_parser::parseStereoPannerOptions(runtime, options);
+  auto stereoPanner = context_->createStereoPanner(stereoPannerOptions);
   auto stereoPannerHostObject = std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
   return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
-  auto biquadFilter = context_->createBiquadFilter();
+  const auto options = args[0].asObject(runtime);
+  const auto biquadFilterOptions = audioapi::option_parser::parseBiquadFilterOptions(runtime, options);
+  auto biquadFilter = context_->createBiquadFilter(biquadFilterOptions);
   auto biquadFilterHostObject = std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
   return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createIIRFilter) {
-  auto feedforwardArray = args[0].asObject(runtime).asArray(runtime);
-  auto feedbackArray = args[1].asObject(runtime).asArray(runtime);
-
-  size_t feedforwardLength = feedforwardArray.length(runtime);
-  size_t feedbackLength = feedbackArray.length(runtime);
-
-  std::vector<float> feedforward;
-  std::vector<float> feedback;
-
-  feedforward.reserve(feedforwardLength);
-  feedback.reserve(feedbackLength);
-
-  for (size_t i = 0; i < feedforwardLength; ++i) {
-    feedforward.push_back(feedforwardArray.getValueAtIndex(runtime, i).asNumber());
-  }
-
-  for (size_t i = 0; i < feedbackLength; ++i) {
-    feedback.push_back(feedbackArray.getValueAtIndex(runtime, i).asNumber());
-  }
-
-  auto iirFilter = context_->createIIRFilter(feedforward, feedback);
+  const auto options = args[0].asObject(runtime);
+  const auto iirFilterOptions = audioapi::option_parser::parseIIRFilterOptions(runtime, options);
+  auto iirFilter = context_->createIIRFilter(iirFilterOptions);
   auto iirFilterHostObject = std::make_shared<IIRFilterNodeHostObject>(iirFilter);
   return jsi::Object::createFromHostObject(runtime, iirFilterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
-  auto pitchCorrection = args[0].asBool();
-  auto bufferSource = context_->createBufferSource(pitchCorrection);
+  const auto options = args[0].asObject(runtime);
+  const auto audioBufferSourceOptions =
+      audioapi::option_parser::parseAudioBufferSourceOptions(runtime, options);
+  auto bufferSource = context_->createBufferSource(audioBufferSourceOptions);
   auto bufferSourceHostObject = std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
   return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
-  auto pitchCorrection = args[0].asBool();
-  auto bufferSource = context_->createBufferQueueSource(pitchCorrection);
+  const auto options = args[0].asObject(runtime);
+  const auto baseAudioBufferSourceOptions =
+      audioapi::option_parser::parseBaseAudioBufferSourceOptions(runtime, options);
+  auto bufferSource = context_->createBufferQueueSource(baseAudioBufferSourceOptions);
   auto bufferStreamSourceHostObject =
       std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
   return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBuffer) {
-  auto numberOfChannels = static_cast<int>(args[0].getNumber());
-  auto length = static_cast<size_t>(args[1].getNumber());
-  auto sampleRate = static_cast<float>(args[2].getNumber());
-  auto buffer = BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
+  const auto options = args[0].asObject(runtime);
+  const auto audioBufferOptions = audioapi::option_parser::parseAudioBufferOptions(runtime, options);
+  auto buffer = BaseAudioContext::createBuffer(audioBufferOptions);
   auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
 
   auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
@@ -294,31 +298,30 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
-  auto analyser = context_->createAnalyser();
+  const auto options = args[0].asObject(runtime);
+  const auto analyserOptions = audioapi::option_parser::parseAnalyserOptions(runtime, options);
+  auto analyser = context_->createAnalyser(analyserOptions);
   auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
   return jsi::Object::createFromHostObject(runtime, analyserHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
-  auto disableNormalization = args[1].getBool();
-  std::shared_ptr<ConvolverNode> convolver;
-  if (args[0].isUndefined()) {
-    convolver = context_->createConvolver(nullptr, disableNormalization);
-  } else {
-    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-    convolver = context_->createConvolver(bufferHostObject->audioBuffer_, disableNormalization);
-  }
+  const auto options = args[0].asObject(runtime);
+  const auto convolverOptions = audioapi::option_parser::parseConvolverOptions(runtime, options);
+  auto convolver = context_->createConvolver(convolverOptions);
   auto convolverHostObject = std::make_shared<ConvolverNodeHostObject>(convolver);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, convolverHostObject);
-  if (!args[0].isUndefined()) {
-    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  if (convolverOptions.bus != nullptr) {
+    auto bufferHostObject = options.getProperty(runtime, "buffer").getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
     jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
   }
   return jsiObject;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWaveShaper) {
-  auto waveShaper = context_->createWaveShaper();
+  const auto options = args[0].asObject(runtime);
+  const auto waveShaperOptions = audioapi::option_parser::parseWaveShaperOptions(runtime, options);
+  auto waveShaper = context_->createWaveShaper(waveShaperOptions);
   auto waveShaperHostObject = std::make_shared<WaveShaperNodeHostObject>(waveShaper);
   return jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
 }

package/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp

@@ -11,6 +11,9 @@ AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
     : AudioBufferBaseSourceNodeHostObject(node) {
   functions_->erase("start");
 
+  addSetters(
+  JSI_EXPORT_PROPERTY_SETTER(AudioBufferQueueSourceNodeHostObject, onBufferEnded));
+
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, start),
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, enqueueBuffer),
@@ -19,6 +22,21 @@ AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, pause));
 }
 
+AudioBufferQueueSourceNodeHostObject::~AudioBufferQueueSourceNodeHostObject() {
+  auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+  // When JSI object is garbage collected (together with the eventual callback),
+  // underlying source node might still be active and try to call the
+  // non-existing callback.
+  audioBufferQueueSourceNode->setOnBufferEndedCallbackId(0);
+}
+
+JSI_PROPERTY_SETTER_IMPL(AudioBufferQueueSourceNodeHostObject, onBufferEnded) {
+    auto audioBufferQueueSourceNode = std::static_pointer_cast<AudioBufferQueueSourceNode>(node_);
+
+    audioBufferQueueSourceNode->setOnBufferEndedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, start) {
   auto when = args[0].getNumber();
 

package/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h

@@ -15,6 +15,10 @@ class AudioBufferQueueSourceNodeHostObject : public AudioBufferBaseSourceNodeHos
   explicit AudioBufferQueueSourceNodeHostObject(
       const std::shared_ptr<AudioBufferQueueSourceNode> &node);
 
+  ~AudioBufferQueueSourceNodeHostObject() override;
+
+  JSI_PROPERTY_SETTER_DECL(onBufferEnded);
+
   JSI_HOST_FUNCTION_DECL(start);
   JSI_HOST_FUNCTION_DECL(pause);
   JSI_HOST_FUNCTION_DECL(enqueueBuffer);

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.cpp

@@ -10,6 +10,12 @@ namespace audioapi {
 StreamerNodeHostObject::StreamerNodeHostObject(const std::shared_ptr<StreamerNode> &node)
     : AudioScheduledSourceNodeHostObject(node) {
   addFunctions(JSI_EXPORT_FUNCTION(StreamerNodeHostObject, initialize));
+  addGetters(JSI_EXPORT_PROPERTY_GETTER(StreamerNodeHostObject, streamPath));
+}
+
+JSI_PROPERTY_GETTER_IMPL(StreamerNodeHostObject, streamPath) {
+  auto streamerNode = std::static_pointer_cast<StreamerNode>(node_);
+  return jsi::String::createFromUtf8(runtime, streamerNode->getStreamPath());
 }
 
 JSI_HOST_FUNCTION_IMPL(StreamerNodeHostObject, initialize) {

package/common/cpp/audioapi/HostObjects/sources/StreamerNodeHostObject.h

@@ -19,6 +19,7 @@ class StreamerNodeHostObject : public AudioScheduledSourceNodeHostObject {
     return SIZE;
   }
 
+  JSI_PROPERTY_GETTER_DECL(streamPath);
   JSI_HOST_FUNCTION_DECL(initialize);
 
  private:

package/common/cpp/audioapi/HostObjects/utils/NodeOptions.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <audioapi/core/effects/PeriodicWave.h>
+#include <audioapi/core/sources/AudioBuffer.h>
+#include <audioapi/core/types/BiquadFilterType.h>
+#include <audioapi/core/types/ChannelCountMode.h>
+#include <audioapi/core/types/ChannelInterpretation.h>
+#include <audioapi/core/types/OscillatorType.h>
+#include <audioapi/core/types/OverSampleType.h>
+#include <audioapi/utils/AudioArray.h>
+
+namespace audioapi {
+struct AudioNodeOptions {
+  int channelCount = 2;
+  ChannelCountMode channelCountMode;
+  ChannelInterpretation channelInterpretation;
+};
+
+struct GainOptions : AudioNodeOptions {
+  float gain;
+};
+
+struct StereoPannerOptions : AudioNodeOptions {
+  float pan;
+};
+
+struct ConvolverOptions : AudioNodeOptions {
+  std::shared_ptr<AudioBuffer> bus;
+  bool disableNormalization;
+};
+
+struct ConstantSourceOptions {
+  float offset;
+};
+
+struct AnalyserOptions : AudioNodeOptions {
+  int fftSize;
+  float minDecibels;
+  float maxDecibels;
+  float smoothingTimeConstant;
+};
+
+struct BiquadFilterOptions : AudioNodeOptions {
+  BiquadFilterType type;
+  float frequency;
+  float detune;
+  float Q;
+  float gain;
+};
+
+struct OscillatorOptions {
+  std::shared_ptr<PeriodicWave> periodicWave;
+  float frequency;
+  float detune;
+  OscillatorType type;
+};
+
+struct BaseAudioBufferSourceOptions {
+  float detune;
+  bool pitchCorrection;
+  float playbackRate;
+};
+
+struct AudioBufferSourceOptions : BaseAudioBufferSourceOptions {
+  std::shared_ptr<AudioBuffer> buffer;
+  bool loop;
+  float loopStart;
+  float loopEnd;
+};
+
+struct StreamerOptions {
+  std::string streamPath;
+};
+
+struct AudioBufferOptions {
+  int numberOfChannels;
+  size_t length;
+  float sampleRate;
+};
+
+struct DelayOptions : AudioNodeOptions {
+  float maxDelayTime;
+  float delayTime;
+};
+
+struct IIRFilterOptions : AudioNodeOptions {
+  std::vector<float> feedforward;
+  std::vector<float> feedback;
+
+  IIRFilterOptions() = default;
+
+  explicit IIRFilterOptions(const AudioNodeOptions options) : AudioNodeOptions(options) {}
+
+  IIRFilterOptions(const std::vector<float> &ff, const std::vector<float> &fb)
+      : feedforward(ff), feedback(fb) {}
+
+  IIRFilterOptions(std::vector<float> &&ff, std::vector<float> &&fb)
+      : feedforward(std::move(ff)), feedback(std::move(fb)) {}
+};
+
+struct WaveShaperOptions : AudioNodeOptions {
+  std::shared_ptr<AudioArray> curve;
+  OverSampleType oversample;
+};
+
+} // namespace audioapi