react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

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

@@ -10,30 +10,32 @@
 #include <utility>
 #include <vector>
 
-#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),                                               \
-      static_cast<jsi::Value (JsiHostObject::*)(                            \
-          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>( \
-          &CLASS::FUNCTION))
+#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), \
+      static_cast<jsi::Value (JsiHostObject::*)( \
+          jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>(&CLASS::FUNCTION))
 
 #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_EXPORT_PROPERTY_GETTER(CLASS, FUNCTION) \
+  std::make_pair( \
+      std::string(#FUNCTION), \
+      static_cast<jsi::Value (JsiHostObject::*)(jsi::Runtime &)>(&CLASS::FUNCTION))
 
 #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_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),                       \
-      static_cast<void (JsiHostObject::*)(          \
-          jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
+  std::make_pair( \
+      std::string(#FUNCTION), \
+      static_cast<void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>(&CLASS::FUNCTION))
 
 namespace audioapi {
 
@@ -52,10 +54,7 @@ class JsiHostObject : public jsi::HostObject {
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
-  void set(
-      jsi::Runtime &runtime,
-      const jsi::PropNameID &name,
-      const jsi::Value &value) override;
+  void set(jsi::Runtime &runtime, const jsi::PropNameID &name, const jsi::Value &value) override;
 
   template <typename... Args>
   void addGetters(Args... args) {
@@ -73,23 +72,17 @@ class JsiHostObject : public jsi::HostObject {
   }
 
  protected:
-  std::unique_ptr<std::unordered_map<
-      std::string,
-      jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
+  std::unique_ptr<std::unordered_map<std::string, jsi::Value (JsiHostObject::*)(jsi::Runtime &)>>
       getters_;
 
   std::unique_ptr<std::unordered_map<
       std::string,
-      jsi::Value (JsiHostObject::*)(
-          jsi::Runtime &,
-          const jsi::Value &,
-          const jsi::Value *,
-          size_t)>>
+      jsi::Value (
+          JsiHostObject::*)(jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t)>>
       functions_;
 
-  std::unique_ptr<std::unordered_map<
-      std::string,
-      void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
+  std::unique_ptr<
+      std::unordered_map<std::string, void (JsiHostObject::*)(jsi::Runtime &, const jsi::Value &)>>
       setters_;
 
  private:

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

@@ -1,12 +1,14 @@
 #include <audioapi/jsi/JsiPromise.h>
+#include <memory>
 #include <stdexcept>
+#include <string>
+#include <utility>
 
 namespace audioapi {
 
 using namespace facebook;
 
-jsi::Value PromiseVendor::createAsyncPromise(
-    std::function<PromiseResolver()> &&function) {
+jsi::Value PromiseVendor::createAsyncPromise(std::function<PromiseResolver()> &&function) {
   auto &runtime = *runtime_;
   auto callInvoker = callInvoker_;
   auto threadPool = threadPool_;
@@ -32,15 +34,11 @@ jsi::Value PromiseVendor::createAsyncPromise(
     return jsi::Value::undefined();
   };
   auto promiseFunction = jsi::Function::createFromHostFunction(
-      runtime,
-      jsi::PropNameID::forUtf8(runtime, "asyncPromise"),
-      2,
-      std::move(promiseLambda));
+      runtime, jsi::PropNameID::forUtf8(runtime, "asyncPromise"), 2, std::move(promiseLambda));
   return promiseCtor.callAsConstructor(runtime, std::move(promiseFunction));
 }
 
-jsi::Value PromiseVendor::createAsyncPromise(
-    std::function<void(Promise &&)> &&function) {
+jsi::Value PromiseVendor::createAsyncPromise(std::function<void(Promise &&)> &&function) {
   auto &runtime = *runtime_;
   auto callInvoker = callInvoker_;
   auto threadPool = threadPool_;
@@ -55,20 +53,14 @@ jsi::Value PromiseVendor::createAsyncPromise(
     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));
+    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));
+      runtime, jsi::PropNameID::forUtf8(runtime, "asyncPromise"), 2, std::move(promiseLambda));
   return promiseCtor.callAsConstructor(runtime, std::move(promiseFunction));
 }
 
@@ -79,13 +71,11 @@ void PromiseVendor::asyncPromiseJob(
     std::shared_ptr<jsi::Function> &&reject) {
   auto resolver = function();
   callInvoker->invokeAsync(
-      [resolver = std::move(resolver),
-       reject = std::move(reject),
-       resolve = std::move(resolve)](jsi::Runtime &runtime) -> void {
+      [resolver = std::move(resolver), reject = std::move(reject), resolve = std::move(resolve)](
+          jsi::Runtime &runtime) -> void {
         auto result = resolver(runtime);
         if (std::holds_alternative<jsi::Value>(result)) {
-          auto valueShared = std::make_shared<jsi::Value>(
-              std::move(std::get<jsi::Value>(result)));
+          auto valueShared = std::make_shared<jsi::Value>(std::move(std::get<jsi::Value>(result)));
           resolve->call(runtime, *valueShared);
         } else {
           auto errorMessage = std::get<std::string>(result);

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

@@ -1,16 +1,15 @@
 #pragma once
 
-
-#include <audioapi/core/utils/Constants.h>
 #include <ReactCommon/CallInvoker.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/utils/ThreadPool.hpp>
 #include <jsi/jsi.h>
-#include <variant>
-#include <thread>
+#include <functional>
 #include <memory>
 #include <string>
+#include <thread>
 #include <utility>
-#include <functional>
-#include <audioapi/utils/ThreadPool.hpp>
+#include <variant>
 
 namespace audioapi {
 
@@ -24,49 +23,60 @@ class Promise {
   };
 
  public:
-    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) 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) 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());
-      });
+  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) 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) 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::shared_ptr<Inner> inner_;
 };
 
-using PromiseResolver = std::function<std::variant<jsi::Value, std::string>(jsi::Runtime&)>;
+using PromiseResolver = std::function<std::variant<jsi::Value, std::string>(jsi::Runtime &)>;
 
 class PromiseVendor {
  public:
-  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)) {}
+  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)) {}
 
   /// @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.
@@ -94,7 +104,7 @@ class PromiseVendor {
   /// @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);
+  jsi::Value createAsyncPromise(std::function<void(Promise &&)> &&function);
 
  private:
   jsi::Runtime *runtime_;
@@ -102,11 +112,10 @@ class PromiseVendor {
   std::shared_ptr<ThreadPool> threadPool_;
 
   static void asyncPromiseJob(
-    std::shared_ptr<react::CallInvoker> callInvoker,
-    std::function<PromiseResolver()> &&function,
-    std::shared_ptr<jsi::Function> &&resolve,
-    std::shared_ptr<jsi::Function> &&reject
-    );
+      std::shared_ptr<react::CallInvoker> callInvoker,
+      std::function<PromiseResolver()> &&function,
+      std::shared_ptr<jsi::Function> &&resolve,
+      std::shared_ptr<jsi::Function> &&reject);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/jsi/RuntimeLifecycleMonitor.cpp

@@ -1,11 +1,12 @@
 #include <audioapi/jsi/RuntimeLifecycleMonitor.h>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 
 namespace audioapi {
 
-static std::unordered_map<
-    jsi::Runtime *,
-    std::unordered_set<RuntimeLifecycleListener *>>
-    listeners;
+static std::unordered_map<jsi::Runtime *, std::unordered_set<RuntimeLifecycleListener *>> listeners;
 
 struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
   jsi::Runtime *rt_;
@@ -21,9 +22,7 @@ struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
   }
 };
 
-void RuntimeLifecycleMonitor::addListener(
-    jsi::Runtime &rt,
-    RuntimeLifecycleListener *listener) {
+void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
   auto listenersSet = listeners.find(&rt);
   if (listenersSet == listeners.end()) {
     // We install a global host object in the provided runtime, this way we can
@@ -43,9 +42,7 @@ void RuntimeLifecycleMonitor::addListener(
   }
 }
 
-void RuntimeLifecycleMonitor::removeListener(
-    jsi::Runtime &rt,
-    RuntimeLifecycleListener *listener) {
+void RuntimeLifecycleMonitor::removeListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
   auto listenersSet = listeners.find(&rt);
   if (listenersSet == listeners.end()) {
     // nothing to do here

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

@@ -27,9 +27,7 @@ struct RuntimeLifecycleListener {
  */
 struct RuntimeLifecycleMonitor {
   static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
-  static void removeListener(
-      jsi::Runtime &rt,
-      RuntimeLifecycleListener *listener);
+  static void removeListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
 };
 
 } // namespace audioapi

package/common/cpp/audioapi/utils/AudioArray.cpp

@@ -1,5 +1,6 @@
 #include <audioapi/dsp/VectorMath.h>
 #include <audioapi/utils/AudioArray.h>
+#include <algorithm>
 
 namespace audioapi {
 
@@ -93,10 +94,7 @@ void AudioArray::sum(
     size_t destinationStart,
     size_t length) {
   dsp::add(
-      data_ + destinationStart,
-      source->getData() + sourceStart,
-      data_ + destinationStart,
-      length);
+      data_ + destinationStart, source->getData() + sourceStart, data_ + destinationStart, length);
 }
 
 void AudioArray::copy(const AudioArray *source) {
@@ -112,10 +110,7 @@ void AudioArray::copy(
     size_t sourceStart,
     size_t destinationStart,
     size_t length) {
-  memcpy(
-      data_ + destinationStart,
-      source->getData() + sourceStart,
-      length * sizeof(float));
+  memcpy(data_ + destinationStart, source->getData() + sourceStart, length * sizeof(float));
 }
 
 } // namespace audioapi

package/common/cpp/audioapi/utils/AudioArray.h

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <algorithm>
-#include <memory>
 #include <cstddef>
 #include <cstring>
+#include <memory>
 
 namespace audioapi {
 
@@ -29,19 +29,11 @@ class AudioArray {
 
   void sum(const AudioArray *source);
   void sum(const AudioArray *source, size_t start, size_t length);
-  void sum(
-      const AudioArray *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void sum(const AudioArray *source, size_t sourceStart, size_t destinationStart, size_t length);
 
   void copy(const AudioArray *source);
   void copy(const AudioArray *source, size_t start, size_t length);
-  void copy(
-      const AudioArray *source,
-      size_t sourceStart,
-      size_t destinationStart,
-      size_t length);
+  void copy(const AudioArray *source, size_t sourceStart, size_t destinationStart, size_t length);
 
  protected:
   float *data_;