expo-modules-core 1.11.13 → 1.12.1

package/android/src/main/cpp/JavaCallback.cpp

@@ -1,65 +1,251 @@
 // Copyright © 2021-present 650 Industries, Inc. (aka Expo)
 
 #include "JavaCallback.h"
-#include "JSIInteropModuleRegistry.h"
+#include "JSIContext.h"
+#include "types/JNIToJSIConverter.h"
+#include "Exceptions.h"
 
-namespace expo {
+#include <fbjni/fbjni.h>
+#include <fbjni/fbjni.h>
+#include <folly/dynamic.h>
+
+#include <functional>
 
-JavaCallback::JavaCallback(Callback callback)
-  : callback(std::move(callback)) {}
+namespace expo {
 
+JavaCallback::JavaCallback(std::shared_ptr<CallbackContext> callbackContext)
+  : callbackContext(std::move(callbackContext)) {}
 
 void JavaCallback::registerNatives() {
   registerHybrid({
-                   makeNativeMethod("invoke", JavaCallback::invoke),
-                   makeNativeMethod("invoke", JavaCallback::invokeBool),
-                   makeNativeMethod("invoke", JavaCallback::invokeInt),
-                   makeNativeMethod("invoke", JavaCallback::invokeDouble),
-                   makeNativeMethod("invoke", JavaCallback::invokeFloat),
-                   makeNativeMethod("invoke", JavaCallback::invokeString),
-                   makeNativeMethod("invoke", JavaCallback::invokeArray),
-                   makeNativeMethod("invoke", JavaCallback::invokeMap),
+                   makeNativeMethod("invokeNative", JavaCallback::invoke),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeBool),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeInt),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeDouble),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeFloat),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeString),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeArray),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeMap),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeSharedRef),
                  });
 }
 
+
 jni::local_ref<JavaCallback::javaobject> JavaCallback::newInstance(
-  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
-  Callback callback
+  JSIContext *jsiContext,
+  std::shared_ptr<CallbackContext> callbackContext
 ) {
-  auto object = JavaCallback::newObjectCxxArgs(std::move(callback));
-  jsiInteropModuleRegistry->jniDeallocator->addReference(object);
+  auto object = JavaCallback::newObjectCxxArgs(std::move(callbackContext));
+  jsiContext->jniDeallocator->addReference(object);
   return object;
 }
 
+template<typename T>
+void JavaCallback::invokeJSFunction(
+  ArgsConverter<T> argsConverter,
+  T arg
+) {
+  const auto jsInvoker = callbackContext->jsCallInvokerHolder;
+  jsInvoker->invokeAsync(
+    [
+      context = std::move(callbackContext),
+      argsConverter = std::move(argsConverter),
+      arg = std::move(arg)
+    ]() -> void {
+      if (!context->jsFunctionHolder.has_value()) {
+        throw std::runtime_error(
+          "JavaCallback was already settled. Cannot invoke it again"
+        );
+      }
+
+      jsi::Function &jsFunction = context->jsFunctionHolder.value();
+      jsi::Runtime &rt = context->rt;
+
+      argsConverter(rt, jsFunction, std::move(arg), context->isRejectCallback);
+      context->jsFunctionHolder.reset();
+    });
+}
+
+template<class T>
+void JavaCallback::invokeJSFunction(T arg) {
+  invokeJSFunction<T>(
+    [](
+      jsi::Runtime &rt,
+      jsi::Function &jsFunction,
+      T arg,
+      bool isRejectCallback
+    ) {
+      jsFunction.call(rt, {jsi::Value(rt, arg)});
+    },
+    arg
+  );
+}
+
 void JavaCallback::invoke() {
-  callback(nullptr);
+  invokeJSFunction<nullptr_t>(
+    [](
+      jsi::Runtime &rt,
+      jsi::Function &jsFunction,
+      nullptr_t arg,
+      bool isRejectCallback
+    ) {
+      jsFunction.call(rt, {jsi::Value::null()});
+    },
+    nullptr
+  );
 }
 
 void JavaCallback::invokeBool(bool result) {
-  callback(result);
+  invokeJSFunction(result);
 }
 
 void JavaCallback::invokeInt(int result) {
-  callback(result);
+  invokeJSFunction(result);
 }
 
 void JavaCallback::invokeDouble(double result) {
-  callback(result);
+  invokeJSFunction(result);
 }
 
 void JavaCallback::invokeFloat(float result) {
-  callback(result);
+  invokeJSFunction(result);
 }
 
 void JavaCallback::invokeString(jni::alias_ref<jstring> result) {
-  callback(result->toStdString());
+  invokeJSFunction<std::string>(
+    [](
+      jsi::Runtime &rt,
+      jsi::Function &jsFunction,
+      std::string arg,
+      bool isRejectCallback
+    ) {
+      std::optional<jsi::Value> extendedString = convertStringToFollyDynamicIfNeeded(
+        rt,
+        arg
+      );
+
+      if (extendedString.has_value()) {
+        const jsi::Value &jsValue = extendedString.value();
+        jsFunction.call(
+          rt,
+          (const jsi::Value *) &jsValue,
+          (size_t) 1
+        );
+        return;
+      }
+
+      jsFunction.call(rt, {jsi::String::createFromUtf8(rt, arg)});
+    },
+    result->toStdString()
+  );
 }
 
 void JavaCallback::invokeArray(jni::alias_ref<react::WritableNativeArray::javaobject> result) {
-  callback(result->cthis()->consume());
+  invokeJSFunction<folly::dynamic>(
+    [](
+      jsi::Runtime &rt,
+      jsi::Function &jsFunction,
+      folly::dynamic arg,
+      bool isRejectCallback
+    ) {
+      jsi::Value convertedArg = jsi::valueFromDynamic(rt, arg);
+      auto enhancedArg = decorateValueForDynamicExtension(rt, convertedArg);
+      if (enhancedArg) {
+        convertedArg = std::move(*enhancedArg);
+      }
+
+      jsFunction.call(
+        rt,
+        (const jsi::Value *) &convertedArg,
+        (size_t) 1
+      );
+    },
+    result->cthis()->consume()
+  );
 }
 
 void JavaCallback::invokeMap(jni::alias_ref<react::WritableNativeMap::javaobject> result) {
-  callback(result->cthis()->consume());
+  invokeJSFunction<folly::dynamic>(
+    [](
+      jsi::Runtime &rt,
+      jsi::Function &jsFunction,
+      folly::dynamic arg,
+      bool isRejectCallback
+    ) {
+      if (isRejectCallback) {
+        auto errorCode = arg.find("code")->second.asString();
+        auto message = arg.find("message")->second.asString();
+
+        auto codedError = makeCodedError(
+          rt,
+          jsi::String::createFromUtf8(rt, errorCode),
+          jsi::String::createFromUtf8(rt, message)
+        );
+
+        jsFunction.call(
+          rt,
+          (const jsi::Value *) &codedError,
+          (size_t) 1
+        );
+
+        return;
+      }
+
+      jsi::Value convertedArg = jsi::valueFromDynamic(rt, arg);
+      auto enhancedArg = decorateValueForDynamicExtension(rt, convertedArg);
+      if (enhancedArg) {
+        convertedArg = std::move(*enhancedArg);
+      }
+
+      jsFunction.call(
+        rt,
+        (const jsi::Value *) &convertedArg,
+        (size_t) 1
+      );
+    },
+    result->cthis()->consume()
+  );
+}
+
+void JavaCallback::invokeSharedRef(jni::alias_ref<SharedRef::javaobject> result) {
+  invokeJSFunction<jni::global_ref<SharedRef::javaobject>>(
+    [](
+      jsi::Runtime &rt,
+      jsi::Function &jsFunction,
+      jni::global_ref<SharedRef::javaobject> arg,
+      bool isRejectCallback
+    ) {
+      const auto jsiContext = getJSIContext(rt);
+      auto native = jni::make_local(arg);
+
+      auto jsClass = jsiContext->getJavascriptClass(native->getClass());
+      auto jsObject = jsClass
+        ->cthis()
+        ->get()
+        ->asFunction(rt)
+        .callAsConstructor(rt)
+        .asObject(rt);
+
+      auto objSharedPtr = std::make_shared<jsi::Object>(std::move(jsObject));
+      auto jsObjectInstance = JavaScriptObject::newInstance(
+        jsiContext,
+        jsiContext->runtimeHolder,
+        objSharedPtr
+      );
+      jni::local_ref<JavaScriptObject::javaobject> jsRef = jni::make_local(
+        jsObjectInstance
+      );
+      jsiContext->registerSharedObject(native, jsRef);
+
+      auto ret = jsi::Value(rt, *objSharedPtr);
+
+      jsFunction.call(
+        rt,
+        (const jsi::Value *) &ret,
+        (size_t) 1
+      );
+    },
+    jni::make_global(result)
+  );
 }
 } // namespace expo

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

@@ -4,17 +4,29 @@
 
 #include "JNIDeallocator.h"
 
+#include <jsi/jsi.h>
 #include <fbjni/fbjni.h>
 #include <folly/dynamic.h>
+#include <variant>
 
 #include <react/jni/WritableNativeArray.h>
 #include <react/jni/WritableNativeMap.h>
+#include <fbjni/detail/CoreClasses.h>
+#include <ReactCommon/CallInvoker.h>
 
 namespace jni = facebook::jni;
 namespace react = facebook::react;
+namespace jsi = facebook::jsi;
 
 namespace expo {
-class JSIInteropModuleRegistry;
+
+struct SharedRef : public jni::JavaClass<SharedRef> {
+  static constexpr const char *kJavaDescriptor = "Lexpo/modules/kotlin/sharedobjects/SharedRef;";
+};
+
+class JSIContext;
+
+typedef std::variant<folly::dynamic, jni::global_ref<SharedRef::javaobject>> CallbackArg;
 
 class JavaCallback : public jni::HybridClass<JavaCallback, Destructible> {
 public:
@@ -22,20 +34,26 @@ public:
     kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaCallback;";
   static auto constexpr TAG = "JavaCallback";
 
-  using Callback = std::function<void(folly::dynamic)>;
+  struct CallbackContext {
+    jsi::Runtime &rt;
+    std::shared_ptr<react::CallInvoker> jsCallInvokerHolder;
+    std::optional<jsi::Function> jsFunctionHolder;
+    bool isRejectCallback;
+  };
 
   static void registerNatives();
 
   static jni::local_ref<JavaCallback::javaobject> newInstance(
-    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
-    Callback callback
+    JSIContext *jsiContext,
+    std::shared_ptr<CallbackContext> callbackContext
   );
 
 private:
-  friend HybridBase;
+  std::shared_ptr<CallbackContext> callbackContext;
 
+  friend HybridBase;
 
-  JavaCallback(Callback callback);
+  JavaCallback(std::shared_ptr<CallbackContext> callback);
 
   void invoke();
 
@@ -53,6 +71,23 @@ private:
 
   void invokeMap(jni::alias_ref<react::WritableNativeMap::javaobject> result);
 
-  Callback callback;
+  void invokeSharedRef(jni::alias_ref<SharedRef::javaobject> result);
+
+  template<class T>
+  using ArgsConverter = std::function<void(
+    jsi::Runtime &rt,
+    jsi::Function &jsFunction,
+    T arg,
+    bool isRejectCallback
+  )>;
+
+  template<class T>
+  inline void invokeJSFunction(
+    ArgsConverter<T> argsConverter,
+    T arg
+  );
+
+  template<class T>
+  inline void invokeJSFunction(T arg);
 };
 } // namespace expo

package/android/src/main/cpp/JavaScriptFunction.cpp

@@ -4,6 +4,8 @@
 #include "types/JNIToJSIConverter.h"
 #include "types/AnyType.h"
 
+#include "JavaScriptObject.h"
+
 namespace expo {
 
 void JavaScriptFunction::registerNatives() {
@@ -31,11 +33,11 @@ std::shared_ptr<jsi::Function> JavaScriptFunction::get() {
 }
 
 jobject JavaScriptFunction::invoke(
+  jni::alias_ref<JavaScriptObject::javaobject> jsThis,
   jni::alias_ref<jni::JArrayClass<jni::JObject>> args,
   jni::alias_ref<ExpectedType::javaobject> expectedReturnType
 ) {
   auto &rt = runtimeHolder.getJSRuntime();
-  auto moduleRegistry = runtimeHolder.getModuleRegistry();
   JNIEnv *env = jni::Environment::current();
 
   size_t size = args->size();
@@ -44,18 +46,30 @@ jobject JavaScriptFunction::invoke(
 
   for (size_t i = 0; i < size; i++) {
     jni::local_ref<jni::JObject> arg = args->getElement(i);
-    convertedArgs.push_back(convert(moduleRegistry, env, rt, std::move(arg)));
+    convertedArgs.push_back(convert(env, rt, std::move(arg)));
   }
 
   // TODO(@lukmccall): add better error handling
-  jsi::Value result = jsFunction->call(rt, (const jsi::Value *) convertedArgs.data(), size);
+  jsi::Value result = jsThis == nullptr ?
+    jsFunction->call(
+      rt,
+      (const jsi::Value *) convertedArgs.data(),
+      size
+    ) :
+    jsFunction->callWithThis(
+      rt,
+      *(jsThis->cthis()->get()),
+      (const jsi::Value *) convertedArgs.data(),
+      size
+    );
+
   auto converter = AnyType(jni::make_local(expectedReturnType)).converter;
-  auto convertedResult = converter->convert(rt, env, moduleRegistry, result);
+  auto convertedResult = converter->convert(rt, env, result);
   return convertedResult;
 }
 
 jni::local_ref<JavaScriptFunction::javaobject> JavaScriptFunction::newInstance(
-  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  JSIContext *jsiContext,
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Function> jsFunction
 ) {
@@ -63,7 +77,7 @@ jni::local_ref<JavaScriptFunction::javaobject> JavaScriptFunction::newInstance(
     std::move(runtime),
     std::move(jsFunction)
   );
-  jsiInteropModuleRegistry->jniDeallocator->addReference(function);
+  jsiContext->jniDeallocator->addReference(function);
   return function;
 }
 } // namespace expo

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

@@ -15,6 +15,8 @@ namespace jsi = facebook::jsi;
 
 namespace expo {
 
+class JavaScriptObject;
+
 /**
  * Represents any JavaScript function. Its purpose is to expose the `jsi::Function` API back to Kotlin.
  */
@@ -27,7 +29,7 @@ public:
   static void registerNatives();
 
   static jni::local_ref<JavaScriptFunction::javaobject> newInstance(
-    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    JSIContext *jsiContext,
     std::weak_ptr<JavaScriptRuntime> runtime,
     std::shared_ptr<jsi::Function> jsFunction
   );
@@ -52,6 +54,7 @@ private:
   std::shared_ptr<jsi::Function> jsFunction;
 
   jobject invoke(
+    jni::alias_ref<jni::HybridClass<JavaScriptObject, Destructible>::javaobject> jsThis,
     jni::alias_ref<jni::JArrayClass<jni::JObject>> args,
     jni::alias_ref<ExpectedType::javaobject> expectedReturnType
   );