react-native-wgpu 0.1.12 → 0.1.14

package/android/CMakeLists.txt

@@ -25,6 +25,7 @@ find_package(fbjni REQUIRED CONFIG)
 
 add_library(${PACKAGE_NAME} SHARED
     ./cpp/cpp-adapter.cpp
+    ./cpp/platform/ThreadUtils.cpp
     ../cpp/rnwgpu/api/GPU.cpp
     ../cpp/rnwgpu/api/GPUAdapter.cpp
     ../cpp/rnwgpu/api/GPUSupportedLimits.cpp
@@ -48,6 +49,8 @@ add_library(${PACKAGE_NAME} SHARED
     ../cpp/jsi/RNFHybridObject.cpp
     ../cpp/jsi/RNFRuntimeCache.cpp
     ../cpp/jsi/RNFWorkletRuntimeRegistry.cpp
+    ../cpp/threading/Dispatcher.cpp
+    ../cpp/threading/ThreadPool.cpp
 )
 
 target_include_directories(
@@ -61,6 +64,7 @@ target_include_directories(
         "${NODE_MODULES_DIR}/react-native/ReactCommon/runtimeexecutor"
         "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/jni"
         "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/java/com/facebook/react/turbomodule/core/jni"
+        "${NODE_MODULES_DIR}/react-native/ReactAndroid/src/main/jni/react/turbomodule"
 
         ../cpp
         ../cpp/rnwgpu
@@ -68,6 +72,8 @@ target_include_directories(
         ../cpp/rnwgpu/api/descriptors
         ../cpp/jsi
         ../cpp/webgpu
+        ../cpp/threading
+        ../cpp/platform
 
         ${libfbjni_include_DIRS}
 )
@@ -84,5 +90,6 @@ target_link_libraries(
         android
         fbjni::fbjni
         ReactAndroid::jsi
+        ReactAndroid::reactnativejni
         webgpu_dawn
     )

package/android/build.gradle

@@ -87,10 +87,10 @@ android {
   }
 
   packagingOptions {
-    exclude "lib/arm64-v8a/libjsi.so"
-    exclude "lib/x86_64/libjsi.so"
-    exclude "lib/x86/libjsi.so"
-    exclude "lib/armeabi-v7a/libjsi.so"
+    excludes = [
+      "**/libjsi.so",
+      "**/libreactnativejni.so",
+    ]
   }
 
   buildFeatures {

package/android/cpp/cpp-adapter.cpp

@@ -5,6 +5,7 @@
 #include <jni.h>
 #include <jsi/jsi.h>
 
+#include <ReactCommon/CallInvokerHolder.h>
 #include <android/native_window_jni.h>
 #include <webgpu/webgpu_cpp.h>
 
@@ -17,13 +18,18 @@
 std::shared_ptr<rnwgpu::RNWebGPUManager> manager;
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUModule_initializeNative(
-    JNIEnv *env, jobject /* this */, jlong jsRuntime, jobject jsInvokerHolder,
-    jobject blobModule) {
+    JNIEnv *env, jobject /* this */, jlong jsRuntime,
+    jobject jsCallInvokerHolder, jobject blobModule) {
   auto runtime = reinterpret_cast<facebook::jsi::Runtime *>(jsRuntime);
   jobject globalBlobModule = env->NewGlobalRef(blobModule);
+  auto jsCallInvoker{
+      facebook::jni::alias_ref<facebook::react::CallInvokerHolder::javaobject>{
+          reinterpret_cast<facebook::react::CallInvokerHolder::javaobject>(
+              jsCallInvokerHolder)} -> cthis()
+          ->getCallInvoker()};
   auto platformContext =
       std::make_shared<rnwgpu::AndroidPlatformContext>(globalBlobModule);
-  manager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, nullptr,
+  manager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsCallInvoker,
                                                       platformContext);
 }
 
@@ -55,7 +61,7 @@ Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   auto nativeSurface = registry.getSurfaceInfo(contextId)->switchToOffscreen();
-  ANativeWindow_release(reinterpret_cast<ANativeWindow *>(nativeSurface));
+  // ANativeWindow_release(reinterpret_cast<ANativeWindow *>(nativeSurface));
 }
 
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceDestroy(

package/android/cpp/platform/ThreadUtils.cpp

@@ -0,0 +1,41 @@
+//
+//  ThreadUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.h"
+#include <pthread.h>
+#include <sstream>
+#include <string>
+#include <sys/prctl.h>
+#include <thread>
+
+namespace margelo {
+
+std::string ThreadUtils::getThreadName() {
+#ifdef HAVE_ANDROID_PTHREAD_SETNAME_NP
+  // Try using pthread APIs
+  pthread_t this_thread = pthread_self();
+  char thread_name[16]; // Thread name length limit in Android is 16 characters
+
+  int result =
+      pthread_getname_np(this_thread, thread_name, sizeof(thread_name));
+  if (result == 0) {
+    return std::string(thread_name);
+  }
+#endif
+
+  // Fall back to this_thread ID
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return "Thread #" + threadId;
+}
+
+void ThreadUtils::setThreadName(const std::string &name) {
+  prctl(PR_SET_NAME, name.c_str(), 0, 0, 0);
+}
+
+} // namespace margelo

package/apple/ApplePlatformContext.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "PlatformContext.h"
+
+namespace rnwgpu {
+
+class ApplePlatformContext : public PlatformContext {
+public:
+  ApplePlatformContext();
+  ~ApplePlatformContext() = default;
+
+  wgpu::Surface makeSurface(wgpu::Instance instance, void *surface, int width,
+                            int height) override;
+
+  ImageData createImageBitmap(std::string blobId, double offset,
+                              double size) override;
+};
+
+} // namespace rnwgpu

package/apple/ApplePlatformContext.mm

@@ -0,0 +1,86 @@
+#include "ApplePlatformContext.h"
+
+#include <TargetConditionals.h>
+
+#import <React/RCTBlobManager.h>
+#import <React/RCTBridge+Private.h>
+#import <ReactCommon/RCTTurboModule.h>
+
+#include "RNWebGPUManager.h"
+#include "WebGPUModule.h"
+
+namespace rnwgpu {
+
+void isSimulatorWithAPIValidation() {
+#if TARGET_OS_SIMULATOR
+  NSDictionary *environment = [[NSProcessInfo processInfo] environment];
+  NSString *metalDeviceWrapperType = environment[@"METAL_DEVICE_WRAPPER_TYPE"];
+
+  if ([metalDeviceWrapperType isEqualToString:@"1"]) {
+    throw std::runtime_error(
+        "To use React Native WebGPU project on the iOS simulator, you need to "
+        "disable the Metal validation API. In 'Edit Scheme,' uncheck 'Metal "
+        "Validation.'");
+  }
+#endif
+}
+
+ApplePlatformContext::ApplePlatformContext() { isSimulatorWithAPIValidation(); }
+
+wgpu::Surface ApplePlatformContext::makeSurface(wgpu::Instance instance,
+                                                void *surface, int width,
+                                                int height) {
+  wgpu::SurfaceDescriptorFromMetalLayer metalSurfaceDesc;
+  metalSurfaceDesc.layer = surface;
+  wgpu::SurfaceDescriptor surfaceDescriptor;
+  surfaceDescriptor.nextInChain = &metalSurfaceDesc;
+  return instance.CreateSurface(&surfaceDescriptor);
+}
+
+ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
+                                                  double offset, double size) {
+  RCTBlobManager *blobManager =
+      [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
+  NSData *blobData =
+      [blobManager resolve:[NSString stringWithUTF8String:blobId.c_str()]
+                    offset:(long)offset
+                      size:(long)size];
+
+  if (!blobData) {
+    throw std::runtime_error("Couldn't retrive blob data");
+  }
+
+  UIImage *image = [UIImage imageWithData:blobData];
+  if (!image) {
+    throw std::runtime_error("Couldn't decode image");
+  }
+
+  CGImageRef cgImage = image.CGImage;
+  size_t width = CGImageGetWidth(cgImage);
+  size_t height = CGImageGetHeight(cgImage);
+  size_t bitsPerComponent = 8;
+  size_t bytesPerRow = width * 4;
+  std::vector<uint8_t> imageData(height * bytesPerRow);
+
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      imageData.data(), width, height, bitsPerComponent, bytesPerRow,
+      colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+
+  CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
+
+  // Now imageData contains a copy of the bitmap data
+
+  CGContextRelease(context);
+  CGColorSpaceRelease(colorSpace);
+
+  // Use the copied data
+  ImageData result;
+  result.width = static_cast<int>(width);
+  result.height = static_cast<int>(height);
+  result.data = imageData;
+  result.format = wgpu::TextureFormat::RGBA8Unorm;
+  return result;
+}
+
+} // namespace rnwgpu

package/apple/MetalView.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#import "WebGPUModule.h"
+#import <UIKit/UIKit.h>
+
+@interface MetalView : UIView
+
+@property NSNumber *contextId;
+
+- (void)configure;
+- (void)update;
+
+@end

package/apple/MetalView.mm

@@ -0,0 +1,58 @@
+#import "MetalView.h"
+#import "webgpu_cpp.h"
+
+#ifndef RCT_NEW_ARCH_ENABLED
+#import <React/RCTViewManager.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+@implementation MetalView {
+  BOOL _isConfigured;
+}
+
++ (Class)layerClass {
+  return [CAMetalLayer class];
+}
+
+- (void)configure {
+  auto size = self.frame.size;
+  std::shared_ptr<rnwgpu::RNWebGPUManager> manager = [WebGPUModule getManager];
+  void *nativeSurface = (__bridge void *)self.layer;
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  auto gpu = manager->_gpu;
+  auto surface = manager->_platformContext->makeSurface(
+      gpu, nativeSurface, size.width, size.height);
+  registry
+      .getSurfaceInfoOrCreate([_contextId intValue], gpu, size.width,
+                              size.height)
+      ->switchToOnscreen(nativeSurface, surface);
+}
+
+- (void)update {
+  auto size = self.frame.size;
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  registry.getSurfaceInfo([_contextId intValue])
+      ->resize(size.width, size.height);
+}
+
+- (void)dealloc {
+  auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+  // Remove the surface info from the registry
+  registry.removeSurfaceInfo([_contextId intValue]);
+}
+
+#ifndef RCT_NEW_ARCH_ENABLED
+// Paper only method
+// TODO: this method is wrong, it appears to call configureSurface instead of
+// updateSurface sometimes
+- (void)reactSetFrame:(CGRect)frame {
+  [super reactSetFrame:frame];
+  if (!_isConfigured) {
+    [self configure];
+    _isConfigured = YES;
+  } else {
+    [self update];
+  }
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/apple/WebGPUModule.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#import "RNWebGPUManager.h"
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNWgpuViewSpec/RNWgpuViewSpec.h>
+@interface WebGPUModule : RCTEventEmitter <NativeWebGPUModuleSpec>
+#else
+@interface WebGPUModule : RCTEventEmitter <RCTBridgeModule>
+#endif
+
+@property(nonatomic, weak) RCTBridge *bridge;
+@property(nonatomic, weak) RCTModuleRegistry *moduleRegistry;
+
++ (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager;
+
+@end

package/apple/WebGPUModule.mm

@@ -0,0 +1,93 @@
+#import "WebGPUModule.h"
+#include "ApplePlatformContext.h"
+#import "GPUCanvasContext.h"
+
+#import <React/RCTBridge+Private.h>
+#import <React/RCTLog.h>
+#import <React/RCTUIManagerUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <jsi/jsi.h>
+#import <memory>
+
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+@implementation WebGPUModule
+
+RCT_EXPORT_MODULE(WebGPUModule)
+
+static std::shared_ptr<rnwgpu::RNWebGPUManager> webgpuManager;
+
++ (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
+  return webgpuManager;
+}
+
+#pragma Setup and invalidation
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+- (void)invalidate {
+  // if (_webgpuManager != nil) {
+  //   [_webgpuManager invalidate];
+  // }
+  webgpuManager = nil;
+}
+
+- (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
+  return webgpuManager;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+  if (webgpuManager != nil) {
+    // Already initialized, ignore call.
+    return @true;
+  }
+  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)[RCTBridge currentBridge];
+  if (!cxxBridge.runtime) {
+    NSLog(@"Failed to install react-native-filament: RCTBridge is not a "
+          @"RCTCxxBridge!");
+    return [NSNumber numberWithBool:NO];
+  }
+
+  jsi::Runtime *runtime = (jsi::Runtime *)cxxBridge.runtime;
+  if (!runtime) {
+    NSLog(@"Failed to install react-native-filament: jsi::Runtime* was null!");
+    return [NSNumber numberWithBool:NO];
+  }
+  std::shared_ptr<react::CallInvoker> jsInvoker = cxxBridge.jsCallInvoker;
+  if (!jsInvoker) {
+    NSLog(@"Failed to install react-native-filament: react::CallInvoker was "
+          @"null!");
+    return [NSNumber numberWithBool:NO];
+  }
+
+  if (!jsInvoker) {
+    jsInvoker = cxxBridge.jsCallInvoker;
+  }
+  std::shared_ptr<rnwgpu::PlatformContext> platformContext =
+      std::make_shared<rnwgpu::ApplePlatformContext>();
+  // TODO: remove allocation here
+  webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
+                                                            platformContext);
+  return @true;
+}
+
+// RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(createSurfaceContext
+//                                        : (double)contextId) {
+//   int contextIdInt = contextId;
+//   RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+//   auto runtime = (jsi::Runtime *)cxxBridge.runtime;
+
+//   return @true;
+// }
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeWebGPUModuleSpecJSI>(params);
+}
+#endif
+
+@end

package/apple/WebGPUView.h

@@ -0,0 +1,15 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#pragma once
+
+#import "MetalView.h"
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WebGPUView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* RCT_NEW_ARCH_ENABLED */

package/apple/WebGPUView.mm

@@ -0,0 +1,68 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "WebGPUView.h"
+
+#import <react/renderer/components/RNWgpuViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNWgpuViewSpec/EventEmitters.h>
+#import <react/renderer/components/RNWgpuViewSpec/Props.h>
+#import <react/renderer/components/RNWgpuViewSpec/RCTComponentViewHelpers.h>
+
+#import "MetalView.h"
+#import "RCTFabricComponentsPlugins.h"
+#import "Utils.h"
+
+using namespace facebook::react;
+
+@implementation WebGPUView
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<WebGPUViewComponentDescriptor>();
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  /*
+    It's important to destroy the Metal Layer before releasing a view
+    to the recycled pool to prevent displaying outdated content from
+    the last usage in the new context.
+  */
+  self.contentView = nil;
+}
+
+- (MetalView *)getContentView {
+  if (!self.contentView) {
+    self.contentView = [MetalView new];
+  }
+  return (MetalView *)self.contentView;
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<const WebGPUViewProps>(_props);
+  const auto &newViewProps =
+      *std::static_pointer_cast<const WebGPUViewProps>(props);
+
+  if (newViewProps.contextId != oldViewProps.contextId) {
+    /*
+      The context is set only once during mounting the component
+      and never changes because it isn't available for users to modify.
+    */
+    MetalView *metalView = [MetalView new];
+    self.contentView = metalView;
+    [metalView setContextId:@(newViewProps.contextId)];
+    [metalView configure];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+- (void)updateLayoutMetrics:(const LayoutMetrics &)layoutMetrics
+           oldLayoutMetrics:(const LayoutMetrics &)oldLayoutMetrics {
+  [super updateLayoutMetrics:layoutMetrics oldLayoutMetrics:oldLayoutMetrics];
+  [(MetalView *)self.contentView update];
+}
+
+Class<RCTComponentViewProtocol> WebGPUViewCls(void) { return WebGPUView.class; }
+
+@end
+#endif

package/apple/WebGPUViewManager.mm

@@ -0,0 +1,23 @@
+#import "MetalView.h"
+#import "RCTBridge.h"
+#import "WebGPUModule.h"
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+
+@interface WebGPUViewManager : RCTViewManager
+@end
+
+@implementation WebGPUViewManager
+
+RCT_EXPORT_MODULE(WebGPUView)
+
+- (UIView *)view {
+  return [MetalView new];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(contextId, NSNumber, UIView) {
+  NSNumber *contextId = [RCTConvert NSNumber:json];
+  [(MetalView *)view setContextId:contextId];
+}
+
+@end

package/apple/platform/ThreadUtils.cpp

@@ -0,0 +1,33 @@
+//
+//  ThreadUtils.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.h"
+#include <pthread.h>
+#include <sstream>
+#include <thread>
+
+namespace margelo {
+
+std::string ThreadUtils::getThreadName() {
+  // Try using pthread APIs
+  char name[256];
+  if (pthread_getname_np(pthread_self(), name, sizeof(name)) == 0) {
+    return std::string(name);
+  }
+
+  // Fall back to this_thread ID
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return "Thread #" + threadId;
+}
+
+void ThreadUtils::setThreadName(const std::string &name) {
+  pthread_setname_np(name.c_str());
+}
+
+} // namespace margelo

package/cpp/jsi/RNFJSIConverter.h

@@ -25,6 +25,9 @@
 #include "RNFPromise.h"
 #include "RNFWorkletRuntimeRegistry.h"
 
+#include "Dispatcher.h"
+#include "ThreadPool.h"
+
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
 #endif
@@ -207,39 +210,55 @@ template <typename TResult> struct JSIConverter<std::future<TResult>> {
   }
   static jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
     auto sharedFuture = std::make_shared<std::future<TResult>>(std::move(arg));
-    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture)](jsi::Runtime& runtime,
+    std::shared_ptr<Dispatcher> strongDispatcher = Dispatcher::getRuntimeGlobalDispatcher(runtime);
+    std::weak_ptr<Dispatcher> weakDispatcher = strongDispatcher;
+
+    return Promise::createPromise(runtime, [sharedFuture = std::move(sharedFuture), weakDispatcher](jsi::Runtime& runtime,
                                                                                            std::shared_ptr<Promise> promise) {
-      try {
-        // wait until the future completes.
+      // Spawn new async thread to synchronously wait for the `future<T>` to complete
+      std::shared_ptr<ThreadPool> pool = ThreadPool::getSharedPool();
+      pool->run([promise, &runtime, weakDispatcher, sharedFuture]() {
+        // synchronously wait until the `future<T>` completes. we are running on a background task here.
         sharedFuture->wait();
 
-        if constexpr (std::is_same_v<TResult, void>) {
-          // it's returning void, just return undefined to JS
-          sharedFuture->get();
-          promise->resolve(jsi::Value::undefined());
-        } else {
-          // it's returning a custom type, convert it to a jsi::Value
-          TResult result = sharedFuture->get();
-          jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
-          promise->resolve(std::move(jsResult));
+        std::shared_ptr<Dispatcher> dispatcher = weakDispatcher.lock();
+        if (!dispatcher) {
+          throw std::runtime_error("Tried resolving Promise on JS Thread, but the `Dispatcher` has already been destroyed!");
+          return;
         }
-      } catch (const std::exception& exception) {
-        // the async function threw an error, reject the promise
-        std::string what = exception.what();
-        promise->reject(what);
-      } catch (...) {
-        // the async function threw a non-std error, try getting it
-#if __has_include(<cxxabi.h>)
-        std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
-#else
-        std::string name = "<unknown>";
-#endif
-        promise->reject("Unknown non-std exception: " + name);
-      }
 
-      // This lambda owns the promise shared pointer, and we need to call its
-      // destructor correctly here - ensuring it's properly handled.
-      promise = nullptr;
+        dispatcher->runAsync([&runtime, promise, sharedFuture]() mutable {
+          try {
+            if constexpr (std::is_same_v<TResult, void>) {
+                // it's returning void, just return undefined to JS
+              sharedFuture->get();
+              promise->resolve(jsi::Value::undefined());
+            } else {
+              // it's returning a custom type, convert it to a jsi::Value
+              TResult result = sharedFuture->get();
+              jsi::Value jsResult = JSIConverter<TResult>::toJSI(runtime, result);
+              promise->resolve(std::move(jsResult));
+            }
+          } catch (const std::exception& exception) {
+            // the async function threw an error, reject the promise
+            std::string what = exception.what();
+            promise->reject(what);
+          } catch (...) {
+            // the async function threw a non-std error, try getting it
+    #if __has_include(<cxxabi.h>)
+            std::string name = __cxxabiv1::__cxa_current_exception_type()->name();
+    #else
+            std::string name = "<unknown>";
+    #endif
+            promise->reject("Unknown non-std exception: " + name);
+          }
+
+          // This lambda owns the promise shared pointer, and we need to call its
+          // destructor correctly here - otherwise it might be called
+          // from the threadPool thread.
+          promise = nullptr;
+        });
+      });
     });
   }
 };