react-native-audio-api 0.3.0-rc1 → 0.3.0-rc2

package/android/src/main/cpp/AudioAPIInstaller/AudioAPIInstaller.cpp

@@ -5,14 +5,18 @@ namespace audioapi {
 using namespace facebook::jni;
 
 AudioAPIInstaller::AudioAPIInstaller(
-    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis)
-    : javaPart_(make_global(jThis)) {}
+    jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+    jsi::Runtime *rnRuntime,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker)
+    : javaPart_(make_global(jThis)),
+      rnRuntime_(rnRuntime),
+      jsCallInvoker_(jsCallInvoker) {}
 
-void AudioAPIInstaller::install(jlong jsContext) {
+void AudioAPIInstaller::install() {
   auto audioAPIInstallerWrapper =
       std::make_shared<AudioAPIInstallerWrapper>(this);
   AudioAPIInstallerHostObject::createAndInstallFromWrapper(
-      audioAPIInstallerWrapper, jsContext);
+      audioAPIInstallerWrapper, rnRuntime_, jsCallInvoker_);
 }
 
 std::shared_ptr<AudioContext> AudioAPIInstaller::createAudioContext() {

package/android/src/main/cpp/AudioAPIInstaller/AudioAPIInstaller.h

@@ -1,7 +1,7 @@
 #pragma once
 
+#include <ReactCommon/CallInvokerHolder.h>
 #include <fbjni/fbjni.h>
-#include <jsi/jsi.h>
 #include <react/jni/CxxModuleWrapper.h>
 #include <react/jni/JMessageQueueThread.h>
 #include <memory>
@@ -14,7 +14,7 @@
 namespace audioapi {
 
 using namespace facebook;
-using namespace facebook::jni;
+using namespace react;
 
 class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
  public:
@@ -22,8 +22,13 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
       "Lcom/swmansion/audioapi/module/AudioAPIInstaller;";
 
   static jni::local_ref<AudioAPIInstaller::jhybriddata> initHybrid(
-      jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+      jni::alias_ref<jhybridobject> jThis,
+      jlong jsContext,
+      jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>
+          jsCallInvokerHolder) {
+    auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+    auto rnRuntime = reinterpret_cast<jsi::Runtime *>(jsContext);
+    return makeCxxInstance(jThis, rnRuntime, jsCallInvoker);
   }
 
   static void registerNatives() {
@@ -34,15 +39,19 @@ class AudioAPIInstaller : public jni::HybridClass<AudioAPIInstaller> {
   }
 
   std::shared_ptr<AudioContext> createAudioContext();
-  void install(jlong jsContext);
+  void install();
 
  private:
   friend HybridBase;
 
-  global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jni::global_ref<AudioAPIInstaller::javaobject> javaPart_;
+  jsi::Runtime *rnRuntime_;
+  std::shared_ptr<facebook::react::CallInvoker> jsCallInvoker_;
 
   explicit AudioAPIInstaller(
-      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis);
+      jni::alias_ref<AudioAPIInstaller::jhybridobject> &jThis,
+      jsi::Runtime *rnRuntime,
+      const std::shared_ptr<facebook::react::CallInvoker> &jsCallInvoker);
 };
 
 } // namespace audioapi

package/android/src/main/cpp/AudioDecoder/AudioDecoder.cpp

@@ -0,0 +1,64 @@
+#include "AudioDecoder.h"
+
+#define MINIAUDIO_IMPLEMENTATION
+#include <android/log.h>
+#include <miniaudio.h>
+
+#include "AudioArray.h"
+#include "AudioBus.h"
+
+namespace audioapi {
+
+AudioDecoder::AudioDecoder(int sampleRate) : sampleRate_(sampleRate) {}
+
+AudioBus *AudioDecoder::decodeWithFilePath(const std::string &path) const {
+  ma_decoder decoder;
+  ma_decoder_config config =
+      ma_decoder_config_init(ma_format_f32, 2, sampleRate_);
+  ma_result result = ma_decoder_init_file(path.c_str(), &config, &decoder);
+  if (result != MA_SUCCESS) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to initialize decoder for file: %s",
+        path.c_str());
+    return new AudioBus(1, 1, 1);
+  }
+
+  ma_uint64 totalFrameCount;
+  ma_decoder_get_length_in_pcm_frames(&decoder, &totalFrameCount);
+
+  auto *audioBus =
+      new AudioBus(sampleRate_, static_cast<int>(totalFrameCount), 2);
+  auto *buffer = new float[totalFrameCount * 2];
+
+  ma_uint64 framesDecoded;
+  ma_decoder_read_pcm_frames(&decoder, buffer, totalFrameCount, &framesDecoded);
+  if (framesDecoded == 0) {
+    __android_log_print(
+        ANDROID_LOG_ERROR,
+        "AudioDecoder",
+        "Failed to decode audio file: %s",
+        path.c_str());
+  }
+
+  for (int i = 0; i < decoder.outputChannels; ++i) {
+    float *channelData = audioBus->getChannel(i)->getData();
+
+    for (ma_uint64 j = 0; j < framesDecoded; ++j) {
+      channelData[j] = buffer[j * decoder.outputChannels + i];
+    }
+  }
+
+  delete[] buffer;
+  ma_decoder_uninit(&decoder);
+
+  return audioBus;
+}
+
+AudioBus *AudioDecoder::decodeWithArrayBuffer() const {
+  // TODO: implement this
+  return new AudioBus(1, 1, 1);
+}
+
+} // namespace audioapi

package/android/src/main/cpp/AudioDecoder/AudioDecoder.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <string>
+
+namespace audioapi {
+
+class AudioBus;
+
+class AudioDecoder {
+ public:
+  explicit AudioDecoder(int sampleRate);
+
+  [[nodiscard]] AudioBus *decodeWithFilePath(const std::string &path) const;
+  // TODO: implement this
+  [[nodiscard]] AudioBus *decodeWithArrayBuffer() const;
+
+ private:
+  int sampleRate_;
+};
+
+} // namespace audioapi

package/android/src/main/cpp/AudioPlayer/AudioPlayer.h

@@ -14,8 +14,8 @@ class AudioPlayer : public AudioStreamDataCallback {
  public:
   explicit AudioPlayer(const std::function<void(AudioBus *, int)> &renderAudio);
 
-  int getSampleRate() const;
-  int getBufferSizeInFrames() const;
+  [[nodiscard]] int getSampleRate() const;
+  [[nodiscard]] int getBufferSizeInFrames() const;
   void start();
   void stop();
 

package/android/src/main/java/com/swmansion/audioapi/module/AudioAPIInstaller.kt

@@ -1,8 +1,14 @@
 package com.swmansion.audioapi.module
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 
-class AudioAPIInstaller {
+@OptIn(FrameworkAPI::class)
+class AudioAPIInstaller(
+  reactContext: ReactApplicationContext,
+) {
   private val mHybridData: HybridData?
 
   companion object {
@@ -12,10 +18,14 @@ class AudioAPIInstaller {
   }
 
   init {
-    mHybridData = initHybrid()
+    val jsCallInvokerHolder = reactContext.jsCallInvokerHolder as CallInvokerHolderImpl
+    mHybridData = initHybrid(reactContext.javaScriptContextHolder!!.get(), jsCallInvokerHolder)
   }
 
-  external fun initHybrid(): HybridData?
+  external fun initHybrid(
+    jsContext: Long,
+    callInvoker: CallInvokerHolderImpl,
+  ): HybridData?
 
-  external fun install(jsContext: Long)
+  external fun install()
 }

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

@@ -12,9 +12,8 @@ class AudioAPIModule(
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   fun install(): Boolean {
-    val audioAPIInstaller = AudioAPIInstaller()
-    val jsContext = reactContext.javaScriptContextHolder!!.get()
-    audioAPIInstaller.install(jsContext)
+    val audioAPIInstaller = AudioAPIInstaller(reactContext)
+    audioAPIInstaller.install()
 
     return true
   }

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.cpp

@@ -4,10 +4,13 @@ namespace audioapi {
 using namespace facebook;
 
 AudioAPIInstallerHostObject::AudioAPIInstallerHostObject(
-    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper, jsi::Runtime* runtime, const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker)
+    const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
+    jsi::Runtime *runtime,
+    const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker)
     : wrapper_(wrapper) {
-      promiseVendor_ = std::make_shared<JsiPromise::PromiseVendor>(runtime, jsInvoker);
-    }
+  promiseVendor_ =
+      std::make_shared<JsiPromise::PromiseVendor>(runtime, jsInvoker);
+}
 
 std::vector<jsi::PropNameID> AudioAPIInstallerHostObject::getPropertyNames(
     jsi::Runtime &runtime) {
@@ -34,7 +37,8 @@ jsi::Value AudioAPIInstallerHostObject::get(
             size_t count) -> jsi::Value {
           auto audioContext = wrapper_->createAudioContext();
           auto audioContextHostObject =
-              AudioContextHostObject::createFromWrapper(audioContext, promiseVendor_);
+              AudioContextHostObject::createFromWrapper(
+                  audioContext, promiseVendor_);
           return jsi::Object::createFromHostObject(
               runtime, audioContextHostObject);
         });

package/common/cpp/AudioAPIInstaller/AudioAPIInstallerHostObject.h

@@ -6,7 +6,6 @@
 #include <utility>
 #include <vector>
 
-
 #include "AudioAPIInstallerWrapper.h"
 #include "AudioContextHostObject.h"
 #include "JsiPromise.h"
@@ -19,17 +18,20 @@ class AudioAPIInstallerWrapper;
 class AudioAPIInstallerHostObject : public jsi::HostObject {
  public:
   explicit AudioAPIInstallerHostObject(
-      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper, jsi::Runtime* runtime, const std::shared_ptr<react::CallInvoker> &jsInvoker);
+      const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &jsInvoker);
 
 #ifdef ANDROID
   static void createAndInstallFromWrapper(
       const std::shared_ptr<AudioAPIInstallerWrapper> &wrapper,
-      jlong jsContext) {
-    auto runtime = reinterpret_cast<jsi::Runtime *>(jsContext);
-    auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(wrapper);
-    auto object = jsi::Object::createFromHostObject(*runtime, hostObject);
-    runtime->global().setProperty(
-        *runtime, "__AudioAPIInstaller", std::move(object));
+      jsi::Runtime *rnRuntime,
+      const std::shared_ptr<react::CallInvoker> &jsInvoker) {
+    auto hostObject = std::make_shared<AudioAPIInstallerHostObject>(
+        wrapper, rnRuntime, jsInvoker);
+    auto object = jsi::Object::createFromHostObject(*rnRuntime, hostObject);
+    rnRuntime->global().setProperty(
+        *rnRuntime, "__AudioAPIInstaller", std::move(object));
   }
 #endif
 

package/common/cpp/HostObjects/AudioBufferHostObject.cpp

@@ -128,8 +128,9 @@ jsi::Value AudioBufferHostObject::get(
         });
   }
 
-  // `decodeAudioData` is a method that returns a promise to AudioBufferHostObject
-  // It seems that async/await checks for the presence of `then` method on the object
+  // `decodeAudioData` is a method that returns a promise to
+  // AudioBufferHostObject It seems that async/await checks for the presence of
+  // `then` method on the object
   if (propName == "then") {
     return jsi::Value::undefined();
   }

package/common/cpp/HostObjects/AudioContextHostObject.cpp

@@ -4,7 +4,8 @@ namespace audioapi {
 using namespace facebook;
 
 AudioContextHostObject::AudioContextHostObject(
-    const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    const std::shared_ptr<AudioContextWrapper> &wrapper,
+    std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
     : BaseAudioContextHostObject(wrapper, promiseVendor) {}
 
 std::vector<jsi::PropNameID> AudioContextHostObject::getPropertyNames(

package/common/cpp/HostObjects/AudioContextHostObject.h

@@ -4,9 +4,9 @@
 #include <memory>
 #include <vector>
 
-#include"JsiPromise.h"
 #include "AudioContextWrapper.h"
 #include "BaseAudioContextHostObject.h"
+#include "JsiPromise.h"
 
 namespace audioapi {
 using namespace facebook;
@@ -14,7 +14,8 @@ using namespace facebook;
 class AudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit AudioContextHostObject(
-      const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
+      const std::shared_ptr<AudioContextWrapper> &wrapper,
+      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 
@@ -26,7 +27,8 @@ class AudioContextHostObject : public BaseAudioContextHostObject {
   std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
   static std::shared_ptr<AudioContextHostObject> createFromWrapper(
-      const std::shared_ptr<AudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
+      const std::shared_ptr<AudioContextWrapper> &wrapper,
+      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor) {
     return std::make_shared<AudioContextHostObject>(wrapper, promiseVendor);
   }
 

package/common/cpp/HostObjects/BaseAudioContextHostObject.cpp

@@ -6,7 +6,8 @@ namespace audioapi {
 using namespace facebook;
 
 BaseAudioContextHostObject::BaseAudioContextHostObject(
-    const std::shared_ptr<BaseAudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
+    const std::shared_ptr<BaseAudioContextWrapper> &wrapper,
+    std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor)
     : wrapper_(wrapper), promiseVendor_(promiseVendor) {
   auto destinationNodeWrapper = wrapper_->getDestination();
   destination_ =
@@ -205,25 +206,34 @@ jsi::Value BaseAudioContextHostObject::get(
   }
 
   if (propName == "decodeAudioDataSource") {
-    auto decode = [this](jsi::Runtime& runtime,
-                         const jsi::Value&,
-                         const jsi::Value* arguments,
-                         size_t count) -> jsi::Value {
+    auto decode = [this](
+                      jsi::Runtime &runtime,
+                      const jsi::Value &,
+                      const jsi::Value *arguments,
+                      size_t count) -> jsi::Value {
       auto sourcePath = arguments[0].getString(runtime).utf8(runtime);
 
-      auto promise = promiseVendor_->createPromise([this, &runtime, sourcePath](std::shared_ptr<JsiPromise::Promise> promise) {
-        std::thread([this, &runtime, sourcePath, promise = std::move(promise)]() {
-          auto results = wrapper_->decodeAudioDataSource(sourcePath);
-          auto audioBufferHostObject = AudioBufferHostObject::createFromWrapper(results);
-
-          promise->resolve(jsi::Object::createFromHostObject(runtime, audioBufferHostObject));
-        }).detach();
-      });
+      auto promise = promiseVendor_->createPromise(
+          [this, &runtime, sourcePath](
+              std::shared_ptr<JsiPromise::Promise> promise) {
+            std::thread([this,
+                         &runtime,
+                         sourcePath,
+                         promise = std::move(promise)]() {
+              auto results = wrapper_->decodeAudioDataSource(sourcePath);
+              auto audioBufferHostObject =
+                  AudioBufferHostObject::createFromWrapper(results);
+
+              promise->resolve(jsi::Object::createFromHostObject(
+                  runtime, audioBufferHostObject));
+            }).detach();
+          });
 
       return promise;
     };
 
-    return jsi::Function::createFromHostFunction(runtime, propNameId, 1, decode);
+    return jsi::Function::createFromHostFunction(
+        runtime, propNameId, 1, decode);
   }
 
   throw std::runtime_error("Not yet implemented!");

package/common/cpp/HostObjects/BaseAudioContextHostObject.h

@@ -5,13 +5,13 @@
 #include <utility>
 #include <vector>
 
-#include "JsiPromise.h"
 #include "AudioBufferHostObject.h"
 #include "AudioBufferSourceNodeHostObject.h"
 #include "AudioDestinationNodeHostObject.h"
 #include "BaseAudioContextWrapper.h"
 #include "BiquadFilterNodeHostObject.h"
 #include "GainNodeHostObject.h"
+#include "JsiPromise.h"
 #include "OscillatorNodeHostObject.h"
 #include "PeriodicWaveHostObject.h"
 #include "StereoPannerNodeHostObject.h"
@@ -22,7 +22,8 @@ using namespace facebook;
 class BaseAudioContextHostObject : public jsi::HostObject {
  public:
   explicit BaseAudioContextHostObject(
-      const std::shared_ptr<BaseAudioContextWrapper> &wrapper, std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
+      const std::shared_ptr<BaseAudioContextWrapper> &wrapper,
+      std::shared_ptr<JsiPromise::PromiseVendor> promiseVendor);
 
   jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override;
 

package/common/cpp/core/AudioDestinationNode.cpp

@@ -31,6 +31,7 @@ void AudioDestinationNode::renderAudio(
   }
 
   context_->getNodeManager()->preProcessGraph();
+
   destinationBus->zero();
 
   AudioBus *processedBus = processAudio(destinationBus, numFrames);

package/common/cpp/core/BaseAudioContext.cpp

@@ -1,4 +1,5 @@
 #ifdef ANDROID
+#include "AudioDecoder.h"
 #include "AudioPlayer.h"
 #else
 #include "IOSAudioDecoder.h"
@@ -24,6 +25,7 @@ namespace audioapi {
 BaseAudioContext::BaseAudioContext() {
 #ifdef ANDROID
   audioPlayer_ = std::make_shared<AudioPlayer>(this->renderAudio());
+  audioDecoder_ = std::make_shared<AudioDecoder>(audioPlayer_->getSampleRate());
 #else
   audioPlayer_ = std::make_shared<IOSAudioPlayer>(this->renderAudio());
   audioDecoder_ =
@@ -108,19 +110,20 @@ std::shared_ptr<PeriodicWave> BaseAudioContext::createPeriodicWave(
 
 #ifdef ANDROID
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
-    const std::string &source) {
-  return {nullptr};
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
+  return std::make_shared<AudioBuffer>(audioBus);
 }
 #else
 std::shared_ptr<AudioBuffer> BaseAudioContext::decodeAudioDataSource(
-    const std::string &source) {
-  auto audioBus = audioDecoder_->decodeWithFilePath(source);
+    const std::string &path) {
+  auto audioBus = audioDecoder_->decodeWithFilePath(path);
   return std::make_shared<AudioBuffer>(audioBus);
 }
 #endif
 
 std::function<void(AudioBus *, int)> BaseAudioContext::renderAudio() {
-  if (isClosed()) {
+  if (!isRunning()) {
     return [](AudioBus *, int) {};
   }
 

package/common/cpp/core/BaseAudioContext.h

@@ -24,6 +24,7 @@ class AudioBufferSourceNode;
 
 #ifdef ANDROID
 class AudioPlayer;
+class AudioDecoder;
 #else
 class IOSAudioPlayer;
 class IOSAudioDecoder;
@@ -33,13 +34,14 @@ class BaseAudioContext {
  public:
   BaseAudioContext();
   ~BaseAudioContext();
+
   std::string getState();
   [[nodiscard]] int getSampleRate() const;
   [[nodiscard]] double getCurrentTime() const;
   [[nodiscard]] int getBufferSizeInFrames() const;
   [[nodiscard]] std::size_t getCurrentSampleFrame() const;
-
   std::shared_ptr<AudioDestinationNode> getDestination();
+
   std::shared_ptr<OscillatorNode> createOscillator();
   std::shared_ptr<GainNode> createGain();
   std::shared_ptr<StereoPannerNode> createStereoPanner();
@@ -52,11 +54,10 @@ class BaseAudioContext {
       float *imag,
       bool disableNormalization,
       int length);
-  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &source);
 
+  std::shared_ptr<AudioBuffer> decodeAudioDataSource(const std::string &path);
   std::shared_ptr<PeriodicWave> getBasicWaveForm(OscillatorType type);
   std::function<void(AudioBus *, int)> renderAudio();
-
   AudioNodeManager *getNodeManager();
   [[nodiscard]] bool isRunning() const;
   [[nodiscard]] bool isClosed() const;
@@ -67,6 +68,7 @@ class BaseAudioContext {
 
 #ifdef ANDROID
   std::shared_ptr<AudioPlayer> audioPlayer_;
+  std::shared_ptr<AudioDecoder> audioDecoder_;
 #else
   std::shared_ptr<IOSAudioPlayer> audioPlayer_;
   std::shared_ptr<IOSAudioDecoder> audioDecoder_;

package/common/cpp/utils/JsiPromise.cpp

@@ -1,56 +1,61 @@
 #include "JsiPromise.h"
 
-#include <jsi/jsi.h>
 #include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
 #include <functional>
 
 namespace JsiPromise {
 
 using namespace facebook;
 
-jsi::Value PromiseVendor::createPromise(std::function<void(std::shared_ptr<Promise>)> func) {
+jsi::Value PromiseVendor::createPromise(
+    std::function<void(std::shared_ptr<Promise>)> func) {
   if (_runtime == nullptr) {
     throw new std::runtime_error("Runtime was null!");
   }
-  auto& runtime = *_runtime;
+  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, func](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](jsi::Value value) -> void {
-      auto valueShared = std::make_shared<jsi::Value>(std::move(value));
-      callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
-        resolve->call(runtime, *valueShared);
-      });
-    };
+  auto runPromise = jsi::Function::createFromHostFunction(
+      runtime,
+      jsi::PropNameID::forUtf8(runtime, "runPromise"),
+      2,
+      [callInvoker, func](
+          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 rejectWrapper = [reject, &runtime, callInvoker](const std::string& errorMessage) -> void {
-      auto error = jsi::JSError(runtime, errorMessage);
-      auto errorShared = std::make_shared<jsi::JSError>(error);
-      callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
-        reject->call(runtime, errorShared->value());
-      });
-    };
+        auto resolveWrapper =
+            [resolve, &runtime, callInvoker](jsi::Value value) -> void {
+          auto valueShared = std::make_shared<jsi::Value>(std::move(value));
+          callInvoker->invokeAsync([resolve, &runtime, valueShared]() -> void {
+            resolve->call(runtime, *valueShared);
+          });
+        };
+
+        auto rejectWrapper = [reject, &runtime, callInvoker](
+                                 const std::string &errorMessage) -> void {
+          auto error = jsi::JSError(runtime, errorMessage);
+          auto errorShared = std::make_shared<jsi::JSError>(error);
+          callInvoker->invokeAsync([reject, &runtime, errorShared]() -> void {
+            reject->call(runtime, errorShared->value());
+          });
+        };
 
-    auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
-    func(promise);
+        auto promise = std::make_shared<Promise>(resolveWrapper, rejectWrapper);
+        func(promise);
 
-    return jsi::Value::undefined();
-  });
+        return jsi::Value::undefined();
+      });
 
   // return new Promise((resolve, reject) => ...)
   return promiseCtor.callAsConstructor(runtime, runPromise);