react-native-nitro-modules 0.16.1 → 0.17.0

package/NitroModules.podspec

@@ -31,6 +31,7 @@ Pod::Spec.new do |s|
     "cpp/core/AnyMap.hpp",
     "cpp/core/ArrayBuffer.hpp",
     "cpp/core/HybridObject.hpp",
+    "cpp/core/Promise.hpp",
     "cpp/entrypoint/HybridNitroModulesProxy.hpp",
     "cpp/entrypoint/InstallNitro.hpp",
     "cpp/registry/HybridObjectRegistry.hpp",
@@ -40,9 +41,9 @@ Pod::Spec.new do |s|
     "cpp/utils/NitroDefines.hpp",
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
-    "ios/core/PromiseHolder.hpp",
     "ios/core/AnyMapHolder.hpp",
     "ios/core/HybridContext.hpp",
+    "ios/utils/RuntimeError.hpp",
     "ios/utils/SwiftClosure.hpp",
   ]
 

package/README.md

@@ -169,12 +169,6 @@ The following C++ / JS types are supported out of the box:
     <td><code>T?</code></td>
     <td><code>T?</code></td>
   </tr>
-  <tr>
-    <td><code>Promise&lt;T&gt;</code></td>
-    <td><code>std::future&lt;T&gt;</code></td>
-    <td><code><a href="./ios/core/Promise.swift">Promise&lt;T&gt;</a></code></td>
-    <td><code><a href="./android/src/main/java/com/margelo/nitro/core/Promise.kt">Promise&lt;T&gt;</a></code></td>
-  </tr>
   <tr>
     <td><code>(T...) =&gt; void</code></td>
     <td><code>std::function&lt;void (T...)&gt;</code></td>
@@ -187,6 +181,12 @@ The following C++ / JS types are supported out of the box:
     <td>❌</td>
     <td>❌</td>
   </tr>
+  <tr>
+    <td><code>Promise&lt;T&gt;</code></td>
+    <td><code>std::shared_ptr&lt;<a href="./cpp/core/Promise.hpp">Promise&lt;T&gt;</a>&gt;</code></td>
+    <td><code><a href="./ios/core/Promise.swift">Promise&lt;T&gt;</a></code></td>
+    <td><code><a href="./android/src/main/java/com/margelo/nitro/core/Promise.kt">Promise&lt;T&gt;</a></code></td>
+  </tr>
   <tr>
     <td><code>{ ... }</code></td>
     <td><code>std::shared_ptr&lt;<a href="./cpp/core/AnyMap.hpp">AnyMap</a>&gt;</code></td>

package/android/build.gradle

@@ -48,9 +48,18 @@ android {
 
     externalNativeBuild {
       cmake {
-        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
         arguments "-DANDROID_STL=c++_shared"
         abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
       }
     }
   }

package/android/src/main/cpp/core/JPromise.hpp

@@ -7,12 +7,30 @@
 
 #pragma once
 
+#include "Promise.hpp"
 #include <fbjni/fbjni.h>
+#include <mutex>
 
 namespace margelo::nitro {
 
 using namespace facebook;
 
+struct JOnResolvedCallback : public jni::JavaClass<JOnResolvedCallback> {
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/Promise$OnResolvedCallback;";
+  void onResolved(const jni::alias_ref<jni::JObject>& result) const {
+    static const auto method = javaClassLocal()->getMethod<void(jni::alias_ref<jni::JObject>)>("onResolved");
+    method(self(), result);
+  }
+};
+
+struct JOnRejectedCallback : public jni::JavaClass<JOnRejectedCallback> {
+  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/Promise$OnRejectedCallback;";
+  void onRejected(const jni::alias_ref<jni::JThrowable>& error) const {
+    static const auto method = javaClassLocal()->getMethod<void(jni::alias_ref<jni::JThrowable>)>("onRejected");
+    method(self(), error);
+  }
+};
+
 /**
  * Represents a Promise implemented in Java.
  */
@@ -20,9 +38,9 @@ class JPromise final : public jni::HybridClass<JPromise> {
 public:
   static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/Promise;";
   using OnResolvedFunc = std::function<void(jni::alias_ref<jni::JObject>)>;
-  using OnRejectedFunc = std::function<void(jni::alias_ref<jni::JString>)>;
+  using OnRejectedFunc = std::function<void(jni::alias_ref<jni::JThrowable>)>;
 
-public:
+private:
   /**
    * Create a new, still unresolved `JPromise` from Java.
    */
@@ -30,14 +48,24 @@ public:
     return makeCxxInstance();
   }
 
+public:
+  /**
+   * Create a new, still unresolved `JPromise` from C++.
+   */
+  static jni::local_ref<JPromise::javaobject> create() {
+    return newObjectCxxArgs();
+  }
+
 public:
   void resolve(jni::alias_ref<jni::JObject> result) {
+    std::unique_lock lock(_mutex);
     _result = jni::make_global(result);
     for (const auto& onResolved : _onResolvedListeners) {
       onResolved(_result);
     }
   }
-  void reject(jni::alias_ref<jni::JString> error) {
+  void reject(jni::alias_ref<jni::JThrowable> error) {
+    std::unique_lock lock(_mutex);
     _error = jni::make_global(error);
     for (const auto& onRejected : _onRejectedListeners) {
       onRejected(_error);
@@ -46,6 +74,7 @@ public:
 
 public:
   void addOnResolvedListener(OnResolvedFunc&& onResolved) {
+    std::unique_lock lock(_mutex);
     if (_result != nullptr) {
       // Promise is already resolved! Call the callback immediately
       onResolved(_result);
@@ -55,6 +84,7 @@ public:
     }
   }
   void addOnRejectedListener(OnRejectedFunc&& onRejected) {
+    std::unique_lock lock(_mutex);
     if (_error != nullptr) {
       // Promise is already rejected! Call the callback immediately
       onRejected(_error);
@@ -65,15 +95,40 @@ public:
   }
 
 private:
-  JPromise() {}
+  void addOnResolvedListenerJava(jni::alias_ref<JOnResolvedCallback> callback) {
+    std::unique_lock lock(_mutex);
+    if (_result != nullptr) {
+      // Promise is already resolved! Call the callback immediately
+      callback->onResolved(_result);
+    } else {
+      // Promise is not yet resolved, put the listener in our queue.
+      auto sharedCallback = jni::make_global(callback);
+      _onResolvedListeners.emplace_back([=](const auto& result) { sharedCallback->onResolved(result); });
+    }
+  }
+  void addOnRejectedListenerJava(jni::alias_ref<JOnRejectedCallback> callback) {
+    std::unique_lock lock(_mutex);
+    if (_error != nullptr) {
+      // Promise is already rejected! Call the callback immediately
+      callback->onRejected(_error);
+    } else {
+      // Promise is not yet rejected, put the listener in our queue.
+      auto sharedCallback = jni::make_global(callback);
+      _onRejectedListeners.emplace_back([=](const auto& error) { sharedCallback->onRejected(error); });
+    }
+  }
+
+private:
+  JPromise() = default;
 
 private:
   friend HybridBase;
   using HybridBase::HybridBase;
   jni::global_ref<jni::JObject> _result;
-  jni::global_ref<jni::JString> _error;
+  jni::global_ref<jni::JThrowable> _error;
   std::vector<OnResolvedFunc> _onResolvedListeners;
   std::vector<OnRejectedFunc> _onRejectedListeners;
+  std::mutex _mutex;
 
 public:
   static void registerNatives() {
@@ -81,6 +136,8 @@ public:
         makeNativeMethod("initHybrid", JPromise::initHybrid),
         makeNativeMethod("nativeResolve", JPromise::resolve),
         makeNativeMethod("nativeReject", JPromise::reject),
+        makeNativeMethod("addOnResolvedListener", JPromise::addOnResolvedListenerJava),
+        makeNativeMethod("addOnRejectedListener", JPromise::addOnRejectedListenerJava),
     });
   }
 };

package/android/src/main/cpp/utils/JUnit.hpp

@@ -0,0 +1,38 @@
+//
+//  JUnit.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 19.11.24.
+//
+
+#pragma once
+
+#include "NitroLogger.hpp"
+#include <fbjni/fbjni.h>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a `Unit` from Kotlin.
+ * This is similar to `void` for Java, but is actually an `Object`.
+ */
+class JUnit final {
+public:
+  /**
+   * Gets the shared instance to `Unit`. This is always a static global.
+   */
+  static jni::alias_ref<jni::JObject> instance() {
+    static jni::global_ref<jni::JObject> sharedInstance = nullptr;
+    if (sharedInstance == nullptr) {
+      jni::alias_ref<jni::JClass> clazz = jni::findClassStatic("java/lang/Object");
+      jni::JConstructor<jobject()> constructor = clazz->getConstructor<jobject()>();
+      jni::local_ref<jobject> instance = clazz->newObject(constructor);
+      sharedInstance = jni::make_global(instance);
+    }
+    return sharedInstance;
+  }
+};
+
+} // namespace margelo::nitro

package/android/src/main/java/com/margelo/nitro/core/Promise.kt

@@ -5,9 +5,11 @@ import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
 import kotlin.concurrent.thread
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
 
 /**
  * Represents a Promise that can be passed to JS.
@@ -23,17 +25,26 @@ import kotlin.concurrent.thread
 @Keep
 @DoNotStrip
 class Promise<T> {
+  @Keep
+  @DoNotStrip
   private val mHybridData: HybridData
 
   /**
    * Creates a new Promise with fully manual control over the `resolve(..)`/`reject(..)` functions
    */
-  init {
+  constructor() {
     mHybridData = initHybrid()
   }
 
+  @Suppress("unused")
+  @Keep
+  @DoNotStrip
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
   /**
-   * Resolves the Promise with the given result.
+   * Resolves the Promise with the given [result].
    * Any `onResolved` listeners will be invoked.
    */
   fun resolve(result: T) {
@@ -41,18 +52,73 @@ class Promise<T> {
   }
 
   /**
-   * Rejects the Promise with the given error.
+   * Rejects the Promise with the given [error].
    * Any `onRejected` listeners will be invoked.
    */
-  fun reject(error: Error) {
-    nativeReject(error.toString())
+  fun reject(error: Throwable) {
+    nativeReject(error)
+  }
+
+  /**
+   * Add a continuation listener to this `Promise<T>`.
+   * Once the `Promise<T>` resolves, the [listener] will be called.
+   */
+  fun then(listener: (result: T) -> Unit): Promise<T> {
+    addOnResolvedListener { boxedResult ->
+      @Suppress("UNCHECKED_CAST")
+      val result = boxedResult as? T ?: throw Error("Failed to cast Object to T!")
+      listener(result)
+    }
+    return this
+  }
+
+  /**
+   * Add an error continuation listener to this `Promise<T>`.
+   * Once the `Promise<T>` rejects, the [listener] will be called with the error.
+   */
+  fun catch(listener: (throwable: Throwable) -> Unit): Promise<T> {
+    addOnRejectedListener(listener)
+    return this
+  }
+
+  /**
+   * Asynchronously await the result of the Promise.
+   * If the Promise is already resolved/rejected, this will continue immediately,
+   * otherwise it will asynchronously wait for a result or throw on a rejection.
+   * This function can only be used from a coroutine context.
+   */
+  suspend fun await(): T {
+    return suspendCoroutine { continuation ->
+      then { result -> continuation.resume(result) }
+      catch { error -> continuation.resumeWithException(error) }
+    }
   }
 
   // C++ functions
   private external fun nativeResolve(result: Any)
-  private external fun nativeReject(error: String)
+  private external fun nativeReject(error: Throwable)
+  private external fun addOnResolvedListener(callback: OnResolvedCallback)
+  private external fun addOnRejectedListener(callback: OnRejectedCallback)
   private external fun initHybrid(): HybridData
 
+  // Nested callbacks - need to be JavaClasses so we can access them with JNI
+  @Keep
+  @DoNotStrip
+  private fun interface OnResolvedCallback {
+    @Suppress("unused")
+    @Keep
+    @DoNotStrip
+    fun onResolved(result: Any)
+  }
+  @Keep
+  @DoNotStrip
+  private fun interface OnRejectedCallback {
+    @Suppress("unused")
+    @Keep
+    @DoNotStrip
+    fun onRejected(error: Throwable)
+  }
+
   companion object {
     private val defaultScope = CoroutineScope(Dispatchers.Default)
 
@@ -71,7 +137,7 @@ class Promise<T> {
         try {
           val result = run()
           promise.resolve(result)
-        } catch (e: Error) {
+        } catch (e: Throwable) {
           promise.reject(e)
         }
       }
@@ -91,7 +157,7 @@ class Promise<T> {
         try {
           val result = run()
           promise.resolve(result)
-        } catch (e: Error) {
+        } catch (e: Throwable) {
           promise.reject(e)
         }
       }
@@ -108,7 +174,7 @@ class Promise<T> {
     /**
      * Creates a new Promise that is already rejected with the given error.
      */
-    fun <T> rejected(error: Error): Promise<T> {
+    fun <T> rejected(error: Throwable): Promise<T> {
       return Promise<T>().apply { reject(error) }
     }
   }

package/cpp/core/HybridFunction.hpp

@@ -16,6 +16,7 @@ struct JSIConverter;
 #include "JSIConverter.hpp"
 #include "NitroDefines.hpp"
 #include "TypeInfo.hpp"
+#include <exception>
 #include <functional>
 #include <jsi/jsi.h>
 #include <memory>

package/cpp/core/Promise.cpp

@@ -0,0 +1,10 @@
+//
+//  Promise.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 18.11.24.
+//
+
+#include "Promise.hpp"
+
+namespace margelo::nitro {} // namespace margelo::nitro