react-native-audio-api 0.8.3 → 0.9.0-nightly-7ecb495-20251008

package/common/cpp/audioapi/core/utils/worklets/WorkletsRunner.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+
+#include <functional>
+#include <atomic>
+#include <memory>
+#include <utility>
+#include <optional>
+
+namespace audioapi {
+using namespace facebook;
+
+/*
+* # How to extract worklet from JavaScript argument
+*
+* To extract a shareable worklet from a JavaScript argument, use the following code:
+*
+* ```cpp
+* auto worklet = worklets::extractSerializableWorkletFromArg(runtime, args[0]);
+* ```
+*
+* This will return a shared pointer to the extracted worklet, or throw an error if the argument is invalid.
+*/
+
+class WorkletsRunner {
+ public:
+    explicit WorkletsRunner(std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime) noexcept;
+
+    /// @brief Execute a job on the UI runtime safely.
+    /// @param job
+    /// @return nullopt if the runtime is not available or the result of the job execution
+    /// @note Execution is synchronous
+    std::optional<jsi::Value> executeOnRuntimeGuardedSync(const std::function<jsi::Value(jsi::Runtime&)>&& job) const noexcept(noexcept(job)) {
+      auto strongRuntime = weakUiRuntime_.lock();
+      if (strongRuntime == nullptr) {
+         return std::nullopt;
+      }
+      #if RN_AUDIO_API_ENABLE_WORKLETS
+      return strongRuntime->executeSync(std::move(job));
+      #else
+      return std::nullopt;
+      #endif
+    }
+
+    /// @brief Execute a worklet with the given arguments.
+    /// @tparam ...Args
+    /// @param shareableWorklet
+    /// @param ...args
+    /// @note Execution is synchronous, this method can be used in `executeOnRuntimeGuardedSync` and `...Async` methods arguments
+    /// @return nullopt if the runtime is not available or the result of the worklet execution
+    template<typename... Args>
+    std::optional<jsi::Value> executeWorklet(const std::shared_ptr<worklets::SerializableWorklet>& shareableWorklet, Args&&... args) {
+      auto strongRuntime = weakUiRuntime_.lock();
+      if (strongRuntime == nullptr) {
+         return std::nullopt;
+      }
+
+      #if RN_AUDIO_API_ENABLE_WORKLETS
+
+      return strongRuntime->runGuarded(shareableWorklet, std::forward<Args>(args)...);
+
+      #else
+      return std::nullopt;
+      #endif
+    }
+
+ private:
+    std::weak_ptr<worklets::WorkletRuntime> weakUiRuntime_;
+};
+
+} // namespace audioapi

package/common/cpp/audioapi/dsp/Windows.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/core/Constants.h>
+#include <audioapi/core/utils/Constants.h>
 #include <audioapi/dsp/Windows.h>
 
 namespace audioapi::dsp {

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.cpp

@@ -1,4 +1,4 @@
-#include <audioapi/HostObjects/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 
 namespace audioapi {

package/common/cpp/audioapi/events/AudioEventHandlerRegistry.h

@@ -53,8 +53,9 @@ class AudioEventHandlerRegistry : public IAudioEventHandlerRegistry {
         "volumeChange",
     };
 
-    static constexpr std::array<std::string_view, 5> AUDIO_API_EVENT_NAMES = {
+    static constexpr std::array<std::string_view, 6> AUDIO_API_EVENT_NAMES = {
       "ended",
+      "loopEnded",
       "audioReady",
       "positionChanged",
       "audioError",

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

@@ -9,7 +9,20 @@ using namespace facebook;
 class AudioArrayBuffer : public jsi::MutableBuffer {
  public:
   AudioArrayBuffer(uint8_t *data, size_t size): data_(data), size_(size) {}
-  ~AudioArrayBuffer() override = default;
+  ~AudioArrayBuffer() override {
+    if (data_ == nullptr) {
+      return;
+    }
+    delete[] data_;
+  }
+  AudioArrayBuffer(AudioArrayBuffer &&other) noexcept
+      : data_(other.data_), size_(other.size_) {
+    other.data_ = nullptr;
+  }
+
+  AudioArrayBuffer(const AudioArrayBuffer &) = delete;
+  AudioArrayBuffer &operator=(const AudioArrayBuffer &) = delete;
+  AudioArrayBuffer &operator=(AudioArrayBuffer &&other) = delete;
 
   [[nodiscard]] size_t size() const override;
   uint8_t *data() override;

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

@@ -10,13 +10,8 @@
 #include <utility>
 #include <vector>
 
-#define JSI_HOST_FUNCTION(NAME)    \
-  jsi::Value NAME(                 \
-      jsi::Runtime &runtime,       \
-      const jsi::Value &thisValue, \
-      const jsi::Value *args,      \
-      size_t count)
-
+#define JSI_HOST_FUNCTION_DECL(name) jsi::Value name(jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)
+#define JSI_HOST_FUNCTION_IMPL(CLASS, name) jsi::Value CLASS::name(jsi::Runtime &runtime, const jsi::Value &thisValue, const jsi::Value *args, size_t count)
 #define JSI_EXPORT_FUNCTION(CLASS, FUNCTION)                                \
   std::make_pair(                                                           \
       std::string(#FUNCTION),                                               \
@@ -24,17 +19,16 @@
           jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>( \
           &CLASS::FUNCTION))
 
-#define JSI_PROPERTY_GETTER(name) jsi::Value name(jsi::Runtime &runtime)
-
+#define JSI_PROPERTY_GETTER_DECL(name) jsi::Value name(jsi::Runtime &runtime)
+#define JSI_PROPERTY_GETTER_IMPL(CLASS, name) jsi::Value CLASS::name(jsi::Runtime &runtime)
 #define JSI_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION)               \
   std::make_pair(                                                 \
       std::string(#FUNCTION),                                     \
       static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>( \
           &CLASS::FUNCTION))
 
-#define JSI_PROPERTY_SETTER(name) \
-  void name(jsi::Runtime &runtime, const jsi::Value &value)
-
+#define JSI_PROPERTY_SETTER_DECL(name) void name(jsi::Runtime &runtime, const jsi::Value &value)
+#define JSI_PROPERTY_SETTER_IMPL(CLASS, name) void CLASS::name(jsi::Runtime &runtime, const jsi::Value &value)
 #define JSI_EXPORT_PROPERTY_SETTER(CLASS, FUNCTION) \
   std::make_pair(                                   \
       std::string(#FUNCTION),                       \

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

@@ -61,4 +61,53 @@ jsi::Value PromiseVendor::createPromise(
   return promiseCtor.callAsConstructor(runtime, runPromise);
 }
 
+jsi::Value PromiseVendor::createAsyncPromise(
+    std::function<std::variant<jsi::Value, std::string>(jsi::Runtime &)>
+        &&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) -> 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));
+
+    threadPool->schedule([callInvoker = std::move(callInvoker),
+                          function = std::move(function),
+                          resolve = std::move(resolve),
+                          reject = std::move(reject),
+                          &runtime]() {
+      auto result = function(runtime);
+      if (std::holds_alternative<jsi::Value>(result)) {
+        auto valueShared = std::make_shared<jsi::Value>(
+            std::move(std::get<jsi::Value>(result)));
+        callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+          resolve->call(runtime, *valueShared);
+        });
+      } else {
+        auto errorMessage = std::get<std::string>(result);
+        callInvoker->invokeAsync([reject, &runtime, errorMessage]() -> void {
+          auto error = jsi::JSError(runtime, errorMessage);
+          reject->call(runtime, error.value());
+        });
+      }
+    });
+    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));
+}
+
 } // namespace audioapi

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

@@ -1,11 +1,16 @@
 #pragma once
 
+
+#include <audioapi/core/utils/Constants.h>
 #include <ReactCommon/CallInvoker.h>
 #include <jsi/jsi.h>
+#include <variant>
+#include <thread>
 #include <memory>
 #include <string>
 #include <utility>
 #include <functional>
+#include <audioapi/utils/ThreadPool.hpp>
 
 namespace audioapi {
 
@@ -30,13 +35,36 @@ class Promise {
 
 class PromiseVendor {
  public:
-  PromiseVendor(jsi::Runtime *runtime, const std::shared_ptr<react::CallInvoker> &callInvoker): runtime_(runtime), callInvoker_(callInvoker) {}
+  PromiseVendor(jsi::Runtime *runtime, const std::shared_ptr<react::CallInvoker> &callInvoker):
+    runtime_(runtime), callInvoker_(callInvoker), threadPool_(std::make_shared<ThreadPool>(
+      audioapi::PROMISE_VENDOR_THREAD_POOL_WORKER_COUNT,
+      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.
+  /// @note The function is executed on a different thread, and the promise is resolved or rejected based on the function's outcome.
+  /// @note IMPORTANT: This function is not thread-safe and should be called from a single thread only. (comes from underlying ThreadPool implementation)
+  /// @example
+  /// ```cpp
+  /// auto promise = promiseVendor_->createAsyncPromise(
+  ///     [](jsi::Runtime& rt) -> std::variant<jsi::Value, std::string> {
+  ///    // Simulate some heavy work
+  ///    std::this_thread::sleep_for(std::chrono::seconds(2));
+  ///    return jsi::String::createFromUtf8(rt, "Promise resolved successfully!");
+  ///  }
+  /// );
+  ///
+  /// return promise;
+  jsi::Value createAsyncPromise(std::function<std::variant<jsi::Value, std::string>(jsi::Runtime&)> &&function);
+
  private:
   jsi::Runtime *runtime_;
   std::shared_ptr<react::CallInvoker> callInvoker_;
+  std::shared_ptr<ThreadPool> threadPool_;
 };
 
 } // namespace audioapi