react-native-audio-api 0.11.0-alpha.1 → 0.11.0-nightly-9f40b78-20251108

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

@@ -1,6 +1,7 @@
 package com.swmansion.audioapi
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
@@ -9,7 +10,6 @@ import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 import com.swmansion.audioapi.system.MediaSessionManager
-import com.swmansion.audioapi.system.NativeFileInfo
 import com.swmansion.audioapi.system.PermissionRequestListener
 import java.lang.ref.WeakReference
 
@@ -17,7 +17,8 @@ import java.lang.ref.WeakReference
 @ReactModule(name = AudioAPIModule.NAME)
 class AudioAPIModule(
   reactContext: ReactApplicationContext,
-) : NativeAudioAPIModuleSpec(reactContext) {
+) : NativeAudioAPIModuleSpec(reactContext),
+  LifecycleEventListener {
   companion object {
     const val NAME = NativeAudioAPIModuleSpec.NAME
   }
@@ -39,6 +40,8 @@ class AudioAPIModule(
     eventBody: Map<String, Any>,
   )
 
+  private external fun closeAllContexts()
+
   init {
     try {
       System.loadLibrary("react-native-audio-api")
@@ -60,12 +63,33 @@ class AudioAPIModule(
 
   override fun install(): Boolean {
     MediaSessionManager.initialize(WeakReference(this), reactContext)
-    NativeFileInfo.initialize(reactContext)
     injectJSIBindings()
 
     return true
   }
 
+  override fun onHostResume() {
+    // do nothing
+  }
+
+  override fun onHostPause() {
+    // do nothing
+  }
+
+  override fun onHostDestroy() {
+    closeAllContexts()
+  }
+
+  override fun initialize() {
+    reactContext.get()?.addLifecycleEventListener(this)
+  }
+
+  override fun invalidate() {
+    closeAllContexts()
+    reactContext.get()?.removeLifecycleEventListener(this)
+    // think about cleaning up resources, singletons etc.
+  }
+
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
 
   override fun setAudioSessionActivity(
@@ -84,6 +108,10 @@ class AudioAPIModule(
     // noting to do here
   }
 
+  override fun disableSessionManagement() {
+    // nothing to do here
+  }
+
   override fun setLockScreenInfo(info: ReadableMap?) {
     MediaSessionManager.setLockScreenInfo(info)
   }

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

@@ -13,12 +13,14 @@ class AudioFocusListener(
   private val audioAPIModule: WeakReference<AudioAPIModule>,
   private val lockScreenManager: WeakReference<LockScreenManager>,
 ) : AudioManager.OnAudioFocusChangeListener {
+  private var playOnAudioFocus: Boolean = false
   private var focusRequest: AudioFocusRequest? = null
 
   override fun onAudioFocusChange(focusChange: Int) {
     Log.d("AudioFocusListener", "onAudioFocusChange: $focusChange")
     when (focusChange) {
       AudioManager.AUDIOFOCUS_LOSS -> {
+        playOnAudioFocus = false
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
@@ -26,23 +28,33 @@ class AudioFocusListener(
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
-
       AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        playOnAudioFocus = lockScreenManager.get()?.isPlaying == true
         val body =
           HashMap<String, Any>().apply {
             put("type", "began")
-            put("shouldResume", false)
+            put("shouldResume", playOnAudioFocus)
           }
         audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
       }
-
       AudioManager.AUDIOFOCUS_GAIN -> {
-        val body =
-          HashMap<String, Any>().apply {
-            put("type", "ended")
-            put("shouldResume", true)
-          }
-        audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
+        if (playOnAudioFocus) {
+          val body =
+            HashMap<String, Any>().apply {
+              put("type", "ended")
+              put("shouldResume", true)
+            }
+          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
+        } else {
+          val body =
+            HashMap<String, Any>().apply {
+              put("type", "ended")
+              put("shouldResume", false)
+            }
+          audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody("interruption", body)
+        }
+
+        playOnAudioFocus = false
       }
     }
   }

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

@@ -42,13 +42,11 @@ class LockScreenManager(
   private var playbackState: Int = PlaybackStateCompat.STATE_PAUSED
 
   init {
-    this.pb.setActions(controls)
-
-    this.nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-    this.nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+    pb.setActions(controls)
+    nb.setPriority(NotificationCompat.PRIORITY_HIGH)
+    nb.setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
 
     updateNotificationMediaStyle()
-
     mediaNotificationManager.get()?.updateActions(controls)
   }
 
@@ -174,8 +172,31 @@ class LockScreenManager(
     if (artworkThread != null && artworkThread!!.isAlive) artworkThread!!.interrupt()
     artworkThread = null
 
-    mediaNotificationManager.get()?.cancelNotification()
+    title = null
+    artist = null
+    album = null
+    description = null
+    duration = 0L
+    speed = 1.0F
+    elapsedTime = 0L
+    artwork = null
+    playbackState = PlaybackStateCompat.STATE_PAUSED
+    isPlaying = false
+
+    val emptyMetadata = MediaMetadataCompat.Builder().build()
+    mediaSession.get()?.setMetadata(emptyMetadata)
+
+    pb.setState(PlaybackStateCompat.STATE_NONE, 0, 0f)
+    pb.setActions(controls)
+    state = pb.build()
+    mediaSession.get()?.setPlaybackState(state)
     mediaSession.get()?.setActive(false)
+
+    nb.setContentTitle("")
+    nb.setContentText("")
+    nb.setContentInfo("")
+
+    mediaNotificationManager.get()?.updateNotification(nb, isPlaying)
   }
 
   fun enableRemoteCommand(

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

@@ -258,5 +258,16 @@ class MediaNotificationManager(
       }
       super.onDestroy()
     }
+
+    override fun onTimeout(startId: Int) {
+      stopForegroundService()
+    }
+
+    override fun onTimeout(
+      startId: Int,
+      fgsType: Int,
+    ) {
+      stopForegroundService()
+    }
   }
 }

package/android/src/oldarch/NativeAudioAPIModuleSpec.java

@@ -50,6 +50,10 @@
    @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);

package/common/cpp/audioapi/AudioAPIModuleInstaller.h

@@ -16,13 +16,16 @@
 #include <audioapi/core/utils/worklets/SafeIncludes.h>
 
 #include <memory>
-#include <string>
+#include <vector>
 
 namespace audioapi {
 
 using namespace facebook;
 
 class AudioAPIModuleInstaller {
+ private:
+  inline static std::vector<std::weak_ptr<AudioContext>> contexts_ = {};
+
  public:
   static void injectJSIBindings(
       jsi::Runtime *jsiRuntime,
@@ -62,6 +65,19 @@ class AudioAPIModuleInstaller {
             *jsiRuntime, audioEventHandlerRegistryHostObject));
   }
 
+  static void closeAllContexts() {
+    for (auto it = contexts_.begin(); it != contexts_.end(); ++it) {
+      auto weakContext = *it;
+
+      if (auto context = weakContext.lock()) {
+        context->close();
+      }
+
+      it = contexts_.erase(it);
+    --it;
+    }
+  }
+
  private:
   static jsi::Function getCreateAudioContextFunction(
       jsi::Runtime *jsiRuntime,
@@ -96,6 +112,8 @@ class AudioAPIModuleInstaller {
               initSuspended,
               audioEventHandlerRegistry,
               runtimeRegistry);
+          AudioAPIModuleInstaller::contexts_.push_back(audioContext);
+
           auto audioContextHostObject =
               std::make_shared<AudioContextHostObject>(
                   audioContext, &runtime, jsCallInvoker);
@@ -139,6 +157,7 @@ class AudioAPIModuleInstaller {
               sampleRate,
               audioEventHandlerRegistry,
               runtimeRegistry);
+
             auto audioContextHostObject =
               std::make_shared<OfflineAudioContextHostObject>(
                     offlineAudioContext, &runtime, jsCallInvoker);
@@ -161,8 +180,17 @@ 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);
+              std::make_shared<AudioRecorderHostObject>(
+                  audioEventHandlerRegistry, sampleRate, bufferLength);
 
           return jsi::Object::createFromHostObject(
               runtime, audioRecorderHostObject);

package/common/cpp/audioapi/HostObjects/AudioContextHostObject.cpp

@@ -17,12 +17,12 @@ AudioContextHostObject::AudioContextHostObject(
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createPromise(
-      [audioContext](const std::shared_ptr<Promise> &promise) {
-        audioContext->close();
-
-        promise->resolve(
-            [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+  auto promise = promiseVendor_->createAsyncPromise(
+      [audioContext = std::move(audioContext)]() {
+        return [audioContext](jsi::Runtime &runtime) {
+          audioContext->close();
+          return jsi::Value::undefined();
+        };
       });
 
   return promise;
@@ -30,25 +30,20 @@ JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, close) {
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, resume) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createPromise(
-      [audioContext](const std::shared_ptr<Promise> &promise) {
+  auto promise = promiseVendor_->createAsyncPromise(
+      [audioContext = std::move(audioContext)]() {
         auto result = audioContext->resume();
-
-        promise->resolve(
-            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
+        return [result](jsi::Runtime &runtime) { return jsi::Value(result); };
       });
-
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioContextHostObject, suspend) {
   auto audioContext = std::static_pointer_cast<AudioContext>(context_);
-  auto promise = promiseVendor_->createPromise(
-      [audioContext](const std::shared_ptr<Promise> &promise) {
+  auto promise = promiseVendor_->createAsyncPromise(
+      [audioContext = std::move(audioContext)]() {
         auto result = audioContext->suspend();
-
-        promise->resolve(
-            [result](jsi::Runtime &runtime) { return jsi::Value(result); });
+        return [result](jsi::Runtime &runtime) { return jsi::Value(result); };
       });
 
   return promise;

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

@@ -5,6 +5,7 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 #include <audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h>
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
+#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
 #include <audioapi/HostObjects/effects/GainNodeHostObject.h>
 #include <audioapi/HostObjects/effects/PeriodicWaveHostObject.h>
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
@@ -49,6 +50,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBufferQueueSource),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createBuffer),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createPeriodicWave),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createConvolver),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createAnalyser));
 }
 
@@ -269,4 +271,20 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
   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);
+  }
+  auto convolverHostObject =
+      std::make_shared<ConvolverNodeHostObject>(convolver);
+  return jsi::Object::createFromHostObject(runtime, convolverHostObject);
+}
 } // namespace audioapi

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

@@ -41,6 +41,7 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createBuffer);
   JSI_HOST_FUNCTION_DECL(createPeriodicWave);
   JSI_HOST_FUNCTION_DECL(createAnalyser);
+  JSI_HOST_FUNCTION_DECL(createConvolver);
 
   std::shared_ptr<BaseAudioContext> context_;
 

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp

@@ -17,49 +17,45 @@ OfflineAudioContextHostObject::OfflineAudioContextHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, resume) {
-  auto promise = promiseVendor_->createPromise(
-      [this](const std::shared_ptr<Promise> &promise) {
-        auto audioContext =
-            std::static_pointer_cast<OfflineAudioContext>(context_);
-        audioContext->resume();
-      });
+  auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+  auto promise = promiseVendor_->createAsyncPromise([audioContext]() {
+    audioContext->resume();
+    return [](jsi::Runtime &runtime) { return jsi::Value::undefined(); };
+  });
 
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
   double when = args[0].getNumber();
+  auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
 
-  auto promise = promiseVendor_->createPromise(
-      [this, when](const std::shared_ptr<Promise> &promise) {
-        auto audioContext =
-            std::static_pointer_cast<OfflineAudioContext>(context_);
-        OfflineAudioContextSuspendCallback callback = [promise]() {
-          promise->resolve(
-              [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
-        };
-        audioContext->suspend(when, callback);
-      });
+  auto promise = promiseVendor_->createAsyncPromise([=](Promise &&promise) {
+    OfflineAudioContextSuspendCallback callback = [promise =
+                                                       std::move(promise)]() {
+      promise.resolve(
+          [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+    };
+    audioContext->suspend(when, callback);
+  });
 
   return promise;
 }
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, startRendering) {
-  auto promise = promiseVendor_->createPromise(
-      [this](const std::shared_ptr<Promise> &promise) {
-        auto audioContext =
-            std::static_pointer_cast<OfflineAudioContext>(context_);
-
+  auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
+  auto promise =
+      promiseVendor_->createAsyncPromise([audioContext](Promise &&promise) {
         OfflineAudioContextResultCallback callback =
-            [promise](const std::shared_ptr<AudioBuffer> &audioBuffer) -> void {
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(audioBuffer);
-          promise->resolve([audioBufferHostObject = std::move(
-                                audioBufferHostObject)](jsi::Runtime &runtime) {
-            return jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject);
-          });
-        };
+            [promise = std::move(promise)](
+                const std::shared_ptr<AudioBuffer> &audioBuffer) {
+              auto audioBufferHostObject =
+                  std::make_shared<AudioBufferHostObject>(audioBuffer);
+              promise.resolve([audioBufferHostObject](jsi::Runtime &runtime) {
+                return jsi::Object::createFromHostObject(
+                    runtime, audioBufferHostObject);
+              });
+            };
 
         audioContext->startRendering(callback);
       });

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp

@@ -67,7 +67,7 @@ JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {
                                   .getArrayBuffer(runtime);
   auto frequencyArray =
       reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
-  auto length = static_cast<int>(arrayBufferFrequency.size(runtime));
+  auto length = static_cast<size_t>(arrayBufferFrequency.size(runtime));
 
   auto arrayBufferMag = args[1]
                             .getObject(runtime)

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp

@@ -0,0 +1,47 @@
+#include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
+
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/core/effects/ConvolverNode.h>
+
+namespace audioapi {
+
+ConvolverNodeHostObject::ConvolverNodeHostObject(
+    const std::shared_ptr<ConvolverNode> &node)
+    : AudioNodeHostObject(node) {
+  addGetters(
+      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, normalize),
+      JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, buffer));
+  addSetters(
+      JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, normalize),
+      JSI_EXPORT_PROPERTY_SETTER(ConvolverNodeHostObject, buffer));
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, normalize) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  return {convolverNode->getNormalize_()};
+}
+
+JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, buffer) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  auto buffer = convolverNode->getBuffer();
+  auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
+  return jsi::Object::createFromHostObject(runtime, bufferHostObject);
+}
+
+JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, normalize) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  convolverNode->setNormalize(value.getBool());
+}
+
+JSI_PROPERTY_SETTER_IMPL(ConvolverNodeHostObject, buffer) {
+  auto convolverNode = std::static_pointer_cast<ConvolverNode>(node_);
+  if (value.isNull()) {
+    convolverNode->setBuffer(nullptr);
+    return;
+  }
+
+  auto bufferHostObject =
+      value.getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  convolverNode->setBuffer(bufferHostObject->audioBuffer_);
+}
+} // namespace audioapi

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <audioapi/HostObjects/AudioNodeHostObject.h>
+
+#include <memory>
+
+namespace audioapi {
+using namespace facebook;
+
+class ConvolverNode;
+
+class ConvolverNodeHostObject : public AudioNodeHostObject {
+ public:
+  explicit ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node);
+  JSI_PROPERTY_GETTER_DECL(normalize);
+  JSI_PROPERTY_GETTER_DECL(buffer);
+  JSI_PROPERTY_SETTER_DECL(normalize);
+  JSI_PROPERTY_SETTER_DECL(buffer);
+};
+} // namespace audioapi