react-native-audio-api 0.11.0-nightly-bfab178-20251107 → 0.11.0-nightly-9f40b78-20251108

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/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/utils/AudioStretcherHostObject.cpp

@@ -24,32 +24,21 @@ JSI_HOST_FUNCTION_IMPL(AudioStretcherHostObject, changePlaybackSpeed) {
       args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
   auto playbackSpeed = static_cast<float>(args[1].asNumber());
 
-  auto promise = promiseVendor_->createPromise(
-      [audioBuffer, playbackSpeed](std::shared_ptr<Promise> promise) {
-        std::thread([audioBuffer,
-                     playbackSpeed,
-                     promise = std::move(promise)]() {
-          auto result = AudioStretcher::changePlaybackSpeed(
-              *audioBuffer->audioBuffer_, playbackSpeed);
-
-          if (!result) {
-            promise->reject("Failed to change audio playback speed.");
-            return;
-          }
-
-          auto audioBufferHostObject =
-              std::make_shared<AudioBufferHostObject>(result);
-
-          promise->resolve([audioBufferHostObject = std::move(
-                                audioBufferHostObject)](jsi::Runtime &runtime) {
-            auto jsiObject = jsi::Object::createFromHostObject(
-                runtime, audioBufferHostObject);
-            jsiObject.setExternalMemoryPressure(
-                runtime, audioBufferHostObject->getSizeInBytes());
-            return jsiObject;
-          });
-        }).detach();
-      });
+  auto promise = promiseVendor_->createAsyncPromise([=]() -> PromiseResolver {
+    auto result = AudioStretcher::changePlaybackSpeed(
+        *audioBuffer->audioBuffer_, playbackSpeed);
+
+    if (result == nullptr) {
+      return [](jsi::Runtime &runtime) {
+        return std::string("Failed to change audio playback speed.");
+      };
+    }
+    return [result](jsi::Runtime &runtime) {
+      auto audioBufferHostObject =
+          std::make_shared<AudioBufferHostObject>(result);
+      return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+    };
+  });
   return promise;
 }
 

package/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp

@@ -31,6 +31,12 @@ void AudioBufferQueueSourceNode::stop(double when) {
   isPaused_ = false;
 }
 
+void AudioBufferQueueSourceNode::start(double when) {
+  isPaused_ = false;
+  stopTime_ = -1.0;
+  AudioScheduledSourceNode::start(when);
+}
+
 void AudioBufferQueueSourceNode::pause() {
   AudioScheduledSourceNode::stop(0.0);
   isPaused_ = true;
@@ -79,6 +85,7 @@ void AudioBufferQueueSourceNode::disable() {
     playbackState_ = PlaybackState::UNSCHEDULED;
     startTime_ = -1.0;
     stopTime_ = -1.0;
+    isPaused_ = false;
 
     return;
   }

package/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h

@@ -21,6 +21,7 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
     ~AudioBufferQueueSourceNode() override;
 
     void stop(double when) override;
+    void start(double when) override;
     void pause();
 
     std::string enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer);

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.cpp

@@ -78,7 +78,6 @@ void AudioScheduledSourceNode::updatePlaybackInfo(
   size_t stopFrame = stopTime_ == -1.0
       ? std::numeric_limits<size_t>::max()
       : dsp::timeToSampleFrame(stopTime_, sampleRate);
-
   if (isFinished()) {
     startOffset = 0;
     nonSilentFramesToProcess = 0;

package/common/cpp/audioapi/core/sources/AudioScheduledSourceNode.h

@@ -28,7 +28,7 @@ class AudioScheduledSourceNode : public AudioNode {
   enum class PlaybackState { UNSCHEDULED, SCHEDULED, PLAYING, STOP_SCHEDULED, FINISHED };
   explicit AudioScheduledSourceNode(BaseAudioContext *context);
 
-  void start(double when);
+  virtual void start(double when);
   virtual void stop(double when);
 
   bool isUnscheduled();

package/common/cpp/audioapi/jsi/JsiPromise.cpp

@@ -5,62 +5,6 @@ namespace audioapi {
 
 using namespace facebook;
 
-jsi::Value PromiseVendor::createPromise(
-    const std::function<void(std::shared_ptr<Promise>)> &function) {
-  if (runtime_ == nullptr) {
-    throw std::runtime_error("Runtime was null!");
-  }
-
-  auto &runtime = *runtime_;
-  auto callInvoker = callInvoker_;
-
-  // get Promise constructor
-  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
-
-  // create a "run" function (first Promise arg)
-  auto runPromise = jsi::Function::createFromHostFunction(
-      runtime,
-      jsi::PropNameID::forUtf8(runtime, "runPromise"),
-      2,
-      [callInvoker, function](
-          jsi::Runtime &runtime,
-          const jsi::Value &thisValue,
-          const jsi::Value *arguments,
-          size_t count) -> jsi::Value {
-        auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
-        auto resolve = std::make_shared<jsi::Function>(std::move(resolveLocal));
-        auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
-        auto reject = std::make_shared<jsi::Function>(std::move(rejectLocal));
-
-        auto resolveWrapper =
-            [resolve, &runtime, callInvoker](
-                const std::function<jsi::Value(jsi::Runtime &)> &resolver)
-            -> void {
-          callInvoker->invokeAsync([resolve, &runtime, resolver]() -> void {
-            auto valueShared = std::make_shared<jsi::Value>(resolver(runtime));
-
-            resolve->call(runtime, *valueShared);
-          });
-        };
-
-        auto rejectWrapper = [reject, &runtime, callInvoker](
-                                 const std::string &errorMessage) -> void {
-          callInvoker->invokeAsync([reject, &runtime, errorMessage]() -> void {
-            auto error = jsi::JSError(runtime, errorMessage);
-            reject->call(runtime, error.value());
-          });
-        };
-
-        auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
-        function(promise);
-
-        return jsi::Value::undefined();
-      });
-
-  // return new Promise((resolve, reject) => ...)
-  return promiseCtor.callAsConstructor(runtime, runPromise);
-}
-
 jsi::Value PromiseVendor::createAsyncPromise(
     std::function<PromiseResolver()> &&function) {
   auto &runtime = *runtime_;
@@ -95,6 +39,39 @@ jsi::Value PromiseVendor::createAsyncPromise(
   return promiseCtor.callAsConstructor(runtime, std::move(promiseFunction));
 }
 
+jsi::Value PromiseVendor::createAsyncPromise(
+    std::function<void(Promise &&)> &&function) {
+  auto &runtime = *runtime_;
+  auto callInvoker = callInvoker_;
+  auto threadPool = threadPool_;
+  auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
+  auto promiseLambda = [threadPool = std::move(threadPool),
+                        callInvoker = std::move(callInvoker),
+                        function = std::move(function)](
+                           jsi::Runtime &runtime,
+                           const jsi::Value &thisValue,
+                           const jsi::Value *arguments,
+                           size_t count) mutable -> jsi::Value {
+    auto resolveLocal = arguments[0].asObject(runtime).asFunction(runtime);
+    auto rejectLocal = arguments[1].asObject(runtime).asFunction(runtime);
+
+    Promise promise(
+        std::move(callInvoker),
+        std::move(resolveLocal),
+        std::move(rejectLocal));
+
+    threadPool->schedule(std::move(function), std::move(promise));
+
+    return jsi::Value::undefined();
+  };
+  auto promiseFunction = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forUtf8(runtime, "asyncPromise"),
+      2,
+      std::move(promiseLambda));
+  return promiseCtor.callAsConstructor(runtime, std::move(promiseFunction));
+}
+
 void PromiseVendor::asyncPromiseJob(
     std::shared_ptr<react::CallInvoker> callInvoker,
     std::function<PromiseResolver()> &&function,

package/common/cpp/audioapi/jsi/JsiPromise.h

@@ -17,20 +17,45 @@ namespace audioapi {
 using namespace facebook;
 
 class Promise {
+  struct Inner {
+    std::shared_ptr<react::CallInvoker> callInvoker;
+    jsi::Function resolve;
+    jsi::Function reject;
+  };
+
  public:
-  Promise(std::function<void(const std::function<jsi::Value(jsi::Runtime&)>)> resolve, std::function<void(const std::string &)> reject) : resolve_(std::move(resolve)), reject_(std::move(reject)) {}
+    explicit Promise(std::shared_ptr<react::CallInvoker> &&callInvoker, jsi::Function &&resolve, jsi::Function &&reject):
+      inner_(std::make_shared<Inner>(Inner{std::move(callInvoker), std::move(resolve), std::move(reject)})) {}
+
+    Promise(const Promise &other) {
+      inner_ = other.inner_;
+    }
+    Promise(Promise &&other) noexcept : inner_(std::move(other.inner_)) {}
+    Promise& operator=(Promise &&other) noexcept {
+      if (this != &other) {
+        inner_ = std::move(other.inner_);
+      }
+      return *this;
+    }
 
-  void resolve(const std::function<jsi::Value(jsi::Runtime&)> &resolver) {
-    resolve_(std::forward<const std::function<jsi::Value(jsi::Runtime&)>>(resolver));
-  }
+    void resolve(const std::function<jsi::Value(jsi::Runtime&)> &&resolver) const {
+      auto inner = inner_;
+      inner->callInvoker->invokeAsync([inner = std::move(inner), resolver = std::forward<decltype(resolver)>(resolver)](jsi::Runtime &runtime) -> void {
+        auto valueShared = std::make_shared<jsi::Value>(resolver(runtime));
+        inner->resolve.call(runtime, *valueShared);
+      });
+    }
 
-  void reject(const std::string &errorMessage) {
-    reject_(errorMessage);
-  }
+    void reject(const std::string &errorMessage) const {
+      auto inner = inner_;
+      inner->callInvoker->invokeAsync([inner = std::move(inner), errorMessage](jsi::Runtime &runtime) -> void {
+        auto error = jsi::JSError(runtime, errorMessage);
+        inner->reject.call(runtime, error.value());
+      });
+    }
 
  private:
-  std::function<void(const std::function<jsi::Value(jsi::Runtime&)>)> resolve_;
-  std::function<void(const std::string &)> reject_;
+  std::shared_ptr<Inner> inner_;
 };
 
 using PromiseResolver = std::function<std::variant<jsi::Value, std::string>(jsi::Runtime&)>;
@@ -43,8 +68,6 @@ class PromiseVendor {
       audioapi::PROMISE_VENDOR_THREAD_POOL_LOAD_BALANCER_QUEUE_SIZE,
       audioapi::PROMISE_VENDOR_THREAD_POOL_WORKER_QUEUE_SIZE)) {}
 
-  jsi::Value createPromise(const std::function<void(std::shared_ptr<Promise>)> &function);
-
   /// @brief Creates an asynchronous promise.
   /// @param function The function to execute asynchronously. It should return either a jsi::Value on success or a std::string error message on failure.
   /// @return The created promise.
@@ -66,6 +89,13 @@ class PromiseVendor {
   /// return promise;
   jsi::Value createAsyncPromise(std::function<PromiseResolver()> &&function);
 
+  /// @brief Creates an asynchronous promise.
+  /// @param function The function to execute asynchronously. It receives a Promise object to resolve or reject the promise.
+  /// @return The created promise.
+  /// @note The function is executed on a different thread, the promise should be resolved or rejected using the provided Promise object.
+  /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only. (comes from underlying ThreadPool implementation)
+  jsi::Value createAsyncPromise(std::function<void(Promise&&)> &&function);
+
  private:
   jsi::Runtime *runtime_;
   std::shared_ptr<react::CallInvoker> callInvoker_;

package/ios/audioapi/ios/AudioAPIModule.mm

@@ -118,15 +118,16 @@ RCT_EXPORT_METHOD(
     setAudioSessionActivity : (BOOL)enabled resolve : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)
         reject)
 {
-  if (!self.audioSessionManager.shouldManageSession) {
-    [self.audioSessionManager setShouldManageSession:true];
-  }
-  if ([self.audioSessionManager setActive:enabled]) {
-    resolve(@"true");
-    return;
-  }
-
-  resolve(@"false");
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    if (!self.audioSessionManager.shouldManageSession) {
+      [self.audioSessionManager setShouldManageSession:true];
+    }
+    if ([self.audioSessionManager setActive:enabled]) {
+      resolve(@"true");
+      return;
+    }
+    resolve(@"false");
+  });
 }
 
 RCT_EXPORT_METHOD(
@@ -173,19 +174,25 @@ RCT_EXPORT_METHOD(
     requestRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)
         reject)
 {
-  [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager requestRecordingPermissions:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(
     checkRecordingPermissions : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager checkRecordingPermissions:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(
     getDevicesInfo : (nonnull RCTPromiseResolveBlock)resolve reject : (nonnull RCTPromiseRejectBlock)reject)
 {
-  [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+    [self.audioSessionManager getDevicesInfo:resolve reject:reject];
+  });
 }
 
 RCT_EXPORT_METHOD(disableSessionManagement)
@@ -233,4 +240,9 @@ RCT_EXPORT_METHOD(disableSessionManagement)
   }
 }
 
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_queue_create("swmansion.audioapi.Queue", DISPATCH_QUEUE_SERIAL);
+}
+
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-api",
-  "version": "0.11.0-nightly-bfab178-20251107",
+  "version": "0.11.0-nightly-9f40b78-20251108",
   "description": "react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification",
   "bin": {
     "setup-rn-audio-api-web": "./scripts/setup-rn-audio-api-web.js"