expo-modules-core 0.10.0 → 0.11.2

package/android/src/main/cpp/JavaScriptModuleObject.cpp

@@ -36,6 +36,8 @@ void JavaScriptModuleObject::registerNatives() {
                                     JavaScriptModuleObject::registerSyncFunction),
                    makeNativeMethod("registerAsyncFunction",
                                     JavaScriptModuleObject::registerAsyncFunction),
+                   makeNativeMethod("registerProperty",
+                                    JavaScriptModuleObject::registerProperty),
                  });
 }
 
@@ -49,8 +51,9 @@ std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &
   return jsiObject;
 }
 
-void JavaScriptModuleObject::exportConstants(jni::alias_ref<react::NativeMap::javaobject>
-  constants) {
+void JavaScriptModuleObject::exportConstants(
+  jni::alias_ref<react::NativeMap::javaobject> constants
+) {
   auto dynamic = constants->cthis()->consume();
   assert(dynamic.isObject());
 
@@ -62,19 +65,73 @@ void JavaScriptModuleObject::exportConstants(jni::alias_ref<react::NativeMap::ja
 void JavaScriptModuleObject::registerSyncFunction(
   jni::alias_ref<jstring> name,
   jint args,
+  jni::alias_ref<jni::JArrayInt> desiredTypes,
   jni::alias_ref<JNIFunctionBody::javaobject> body
 ) {
-  auto cName = name->toStdString();
-  methodsMetadata.try_emplace(cName, cName, args, false, jni::make_global(body));
+  std::string cName = name->toStdString();
+  std::unique_ptr<int[]> types = desiredTypes->getRegion(0, args);
+
+  methodsMetadata.try_emplace(
+    cName,
+    cName,
+    args,
+    false,
+    std::move(types),
+    jni::make_global(body)
+  );
 }
 
 void JavaScriptModuleObject::registerAsyncFunction(
   jni::alias_ref<jstring> name,
   jint args,
+  jni::alias_ref<jni::JArrayInt> desiredTypes,
   jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
 ) {
   auto cName = name->toStdString();
-  methodsMetadata.try_emplace(cName, cName, args, true, jni::make_global(body));
+  std::unique_ptr<int[]> types = desiredTypes->getRegion(0, args);
+
+  methodsMetadata.try_emplace(
+    cName,
+    cName,
+    args,
+    true,
+    std::move(types),
+    jni::make_global(body)
+  );
+}
+
+void JavaScriptModuleObject::registerProperty(
+  jni::alias_ref<jstring> name,
+  jint desiredType,
+  jni::alias_ref<JNIFunctionBody::javaobject> getter,
+  jni::alias_ref<JNIFunctionBody::javaobject> setter
+) {
+  auto cName = name->toStdString();
+  std::unique_ptr<int[]> types = std::make_unique<int[]>(1);
+  types[0] = desiredType;
+
+  auto getterMetadata = MethodMetadata(
+    cName,
+    0,
+    false,
+    std::make_unique<int[]>(0),
+    jni::make_global(getter)
+  );
+
+  auto setterMetadata = MethodMetadata(
+    cName,
+    1,
+    false,
+    std::move(types),
+    jni::make_global(setter)
+  );
+
+  auto functions = std::make_pair(
+    std::move(getterMetadata),
+    std::move(setterMetadata)
+  );
+
+  properties.insert({cName, std::move(functions)});
 }
 
 JavaScriptModuleObject::HostObject::HostObject(
@@ -90,6 +147,12 @@ jsi::Value JavaScriptModuleObject::HostObject::get(jsi::Runtime &runtime,
     return jsi::valueFromDynamic(runtime, dynamic);
   }
 
+  auto propertyRecord = jsModule->properties.find(cName);
+  if (propertyRecord != jsModule->properties.end()) {
+    auto&[getter, _] = propertyRecord->second;
+    return getter.callSync(runtime, jsModule->jsiInteropModuleRegistry, nullptr, 0);
+  }
+
   auto metadataRecord = jsModule->methodsMetadata.find(cName);
   if (metadataRecord == jsModule->methodsMetadata.end()) {
     return jsi::Value::undefined();
@@ -103,6 +166,14 @@ void JavaScriptModuleObject::HostObject::set(
   const jsi::PropNameID &name,
   const jsi::Value &value
 ) {
+  auto cName = name.utf8(runtime);
+  auto propertyRecord = jsModule->properties.find(cName);
+  if (propertyRecord != jsModule->properties.end()) {
+    auto&[_, setter] = propertyRecord->second;
+    setter.callSync(runtime, jsModule->jsiInteropModuleRegistry, &value, 1);
+    return;
+  }
+
   throw jsi::JSError(
     runtime,
     "RuntimeError: Cannot override the host object for expo module '" + name.utf8(runtime) + "'"
@@ -133,6 +204,16 @@ std::vector<jsi::PropNameID> JavaScriptModuleObject::HostObject::getPropertyName
     }
   );
 
+  auto &properties = jsModule->properties;
+  std::transform(
+    properties.begin(),
+    properties.end(),
+    std::back_inserter(result),
+    [&rt](const auto &kv) {
+      return jsi::PropNameID::forUtf8(rt, kv.first);
+    }
+  );
+
   return result;
 }
 } // namespace expo

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

@@ -7,7 +7,7 @@
 #include <react/jni/ReadableNativeArray.h>
 #include <jni/JCallback.h>
 
-#include <map>
+#include <unordered_map>
 
 #include "MethodMetadata.h"
 #include "JNIFunctionBody.h"
@@ -59,7 +59,8 @@ public:
   void registerSyncFunction(
     jni::alias_ref<jstring> name,
     jint args,
-    jni::alias_ref<JNIFunctionBody::javaobject> JSIFunctionBody
+    jni::alias_ref<jni::JArrayInt> desiredTypes,
+    jni::alias_ref<JNIFunctionBody::javaobject> body
   );
 
   /**
@@ -69,7 +70,22 @@ public:
   void registerAsyncFunction(
     jni::alias_ref<jstring> name,
     jint args,
-    jni::alias_ref<JNIAsyncFunctionBody::javaobject> JSIAsyncFunctionBody
+    jni::alias_ref<jni::JArrayInt> desiredTypes,
+    jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
+  );
+
+  /**
+   * Registers a property
+   * @param name of the property
+   * @param desiredType of the setter argument
+   * @param getter body for the get method - can be nullptr
+   * @param setter body for the set method - can be nullptr
+   */
+  void registerProperty(
+    jni::alias_ref<jstring> name,
+    jint desiredType,
+    jni::alias_ref<JNIFunctionBody::javaobject> getter,
+    jni::alias_ref<JNIFunctionBody::javaobject> setter
   );
 
   /**
@@ -109,12 +125,18 @@ private:
   /**
    * Metadata map that stores information about all available methods on this module.
    */
-  std::map<std::string, MethodMetadata> methodsMetadata;
+  std::unordered_map<std::string, MethodMetadata> methodsMetadata;
 
   /**
    * A constants map.
    */
-  std::map<std::string, folly::dynamic> constants;
+  std::unordered_map<std::string, folly::dynamic> constants;
+
+  /**
+   * A registry of properties
+   * The first MethodMetadata points to the getter and the second one to the setter.
+   */
+  std::map<std::string, std::pair<MethodMetadata, MethodMetadata>> properties;
 
   explicit JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis)
     : javaPart_(jni::make_global(jThis)) {}

package/android/src/main/cpp/JavaScriptRuntime.cpp

@@ -37,13 +37,6 @@ JavaScriptRuntime::JavaScriptRuntime()
     .withEnableSampleProfiling(false);
   runtime = facebook::hermes::makeHermesRuntime(config.build());
 
-  // By default "global" property isn't set in the Hermes.
-  runtime->global().setProperty(
-    *runtime,
-    jsi::PropNameID::forUtf8(*runtime, "global"),
-    runtime->global()
-  );
-
   // This version of the Hermes uses a Promise implementation that is provided by the RN.
   // The `setImmediate` function isn't defined, but is required by the Promise implementation.
   // That's why we inject it here.
@@ -67,6 +60,13 @@ JavaScriptRuntime::JavaScriptRuntime()
 #else
   runtime = facebook::jsc::makeJSCRuntime();
 #endif
+
+  // By default "global" property isn't set.
+  runtime->global().setProperty(
+    *runtime,
+    jsi::PropNameID::forUtf8(*runtime, "global"),
+    runtime->global()
+  );
 }
 
 JavaScriptRuntime::JavaScriptRuntime(
@@ -87,10 +87,10 @@ jsi::Runtime *JavaScriptRuntime::get() {
 jni::local_ref<JavaScriptValue::javaobject>
 JavaScriptRuntime::evaluateScript(const std::string &script) {
   auto scriptBuffer = std::make_shared<jsi::StringBuffer>(script);
-  std::shared_ptr<jsi::Value> result;
   try {
-    result = std::make_shared<jsi::Value>(
-      runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>")
+    return JavaScriptValue::newObjectCxxArgs(
+      weak_from_this(),
+      std::make_shared<jsi::Value>(runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>"))
     );
   } catch (const jsi::JSError &error) {
     jni::throwNewJavaException(
@@ -107,8 +107,6 @@ JavaScriptRuntime::evaluateScript(const std::string &script) {
       ).get()
     );
   }
-
-  return JavaScriptValue::newObjectCxxArgs(weak_from_this(), result);
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptRuntime::global() {

package/android/src/main/cpp/MethodMetadata.cpp

@@ -1,6 +1,13 @@
 #include "MethodMetadata.h"
-
 #include "JSIInteropModuleRegistry.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+#include "CachedReferencesRegistry.h"
+
+#include <utility>
+
+#include "react/jni/ReadableNativeMap.h"
+#include "react/jni/ReadableNativeArray.h"
 
 namespace jni = facebook::jni;
 namespace jsi = facebook::jsi;
@@ -68,15 +75,91 @@ jni::local_ref<react::JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunct
   return react::JCxxCallbackImpl::newObjectCxxArgs(fn);
 }
 
+std::vector<jvalue> MethodMetadata::convertJSIArgsToJNI(
+  JSIInteropModuleRegistry *moduleRegistry,
+  JNIEnv *env,
+  jsi::Runtime &rt,
+  const jsi::Value *args,
+  size_t count,
+  bool returnGlobalReferences
+) {
+  std::vector<jvalue> result(count);
+
+  auto makeGlobalIfNecessary = [env, returnGlobalReferences](jobject obj) -> jobject {
+    if (returnGlobalReferences) {
+      return env->NewGlobalRef(obj);
+    }
+    return obj;
+  };
+
+  for (unsigned int argIndex = 0; argIndex < count; argIndex++) {
+    const jsi::Value *arg = &args[argIndex];
+    jvalue *jarg = &result[argIndex];
+    int desiredType = desiredTypes[argIndex];
+
+    if (desiredType & CppType::JS_VALUE) {
+      jarg->l = makeGlobalIfNecessary(
+        JavaScriptValue::newObjectCxxArgs(
+          moduleRegistry->runtimeHolder->weak_from_this(),
+          // TODO(@lukmccall): make sure that copy here is necessary
+          std::make_shared<jsi::Value>(jsi::Value(rt, *arg))
+        ).release()
+      );
+    } else if (desiredType & CppType::JS_OBJECT) {
+      jarg->l = makeGlobalIfNecessary(
+        JavaScriptObject::newObjectCxxArgs(
+          moduleRegistry->runtimeHolder->weak_from_this(),
+          std::make_shared<jsi::Object>(arg->getObject(rt))
+        ).release()
+      );
+    } else if (arg->isNull() || arg->isUndefined()) {
+      jarg->l = nullptr;
+    } else if (arg->isNumber()) {
+      auto &doubleClass = CachedReferencesRegistry::instance()
+        ->getJClass("java/lang/Double");
+      jmethodID doubleConstructor = doubleClass.getMethod("<init>", "(D)V");
+      jarg->l = makeGlobalIfNecessary(
+        env->NewObject(doubleClass.clazz, doubleConstructor, arg->getNumber()));
+    } else if (arg->isBool()) {
+      auto &booleanClass = CachedReferencesRegistry::instance()
+        ->getJClass("java/lang/Boolean");
+      jmethodID booleanConstructor = booleanClass.getMethod("<init>", "(Z)V");
+      jarg->l = makeGlobalIfNecessary(
+        env->NewObject(booleanClass.clazz, booleanConstructor, arg->getBool()));
+    } else if (arg->isString()) {
+      jarg->l = makeGlobalIfNecessary(env->NewStringUTF(arg->getString(rt).utf8(rt).c_str()));
+    } else if (arg->isObject()) {
+      const jsi::Object object = arg->getObject(rt);
+
+      // TODO(@lukmccall): stop using dynamic
+      auto dynamic = jsi::dynamicFromValue(rt, *arg);
+      if (arg->getObject(rt).isArray(rt)) {
+        jarg->l = makeGlobalIfNecessary(
+          react::ReadableNativeArray::newObjectCxxArgs(std::move(dynamic)).release());
+      } else {
+        jarg->l = makeGlobalIfNecessary(
+          react::ReadableNativeMap::createWithContents(std::move(dynamic)).release());
+      }
+    } else {
+      // TODO(@lukmccall): throw an exception
+      jarg->l = nullptr;
+    }
+  }
+
+  return result;
+}
+
 MethodMetadata::MethodMetadata(
   std::string name,
   int args,
   bool isAsync,
+  std::unique_ptr<int[]> desiredTypes,
   jni::global_ref<jobject> &&jBodyReference
-) : name(name),
+) : name(std::move(name)),
     args(args),
     isAsync(isAsync),
-    jBodyReference(jBodyReference) {}
+    desiredTypes(std::move(desiredTypes)),
+    jBodyReference(std::move(jBodyReference)) {}
 
 std::shared_ptr<jsi::Function> MethodMetadata::toJSFunction(
   jsi::Runtime &runtime,
@@ -86,49 +169,86 @@ std::shared_ptr<jsi::Function> MethodMetadata::toJSFunction(
     if (isAsync) {
       body = std::make_shared<jsi::Function>(toAsyncFunction(runtime, moduleRegistry));
     } else {
-      body = std::make_shared<jsi::Function>(toSyncFunction(runtime));
+      body = std::make_shared<jsi::Function>(toSyncFunction(runtime, moduleRegistry));
     }
   }
 
   return body;
 }
 
-jsi::Function MethodMetadata::toSyncFunction(jsi::Runtime &runtime) {
+jsi::Function MethodMetadata::toSyncFunction(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry
+) {
   return jsi::Function::createFromHostFunction(
     runtime,
     jsi::PropNameID::forAscii(runtime, name),
     args,
-    [this](
+    [this, moduleRegistry](
       jsi::Runtime &rt,
       const jsi::Value &thisValue,
       const jsi::Value *args,
       size_t count
     ) -> jsi::Value {
-      auto dynamicArray = folly::dynamic::array();
-      for (int i = 0; i < count; i++) {
-        auto &arg = args[i];
-        dynamicArray.push_back(jsi::dynamicFromValue(rt, arg));
-      }
-
-      // Cast in this place is safe, cause we know that this function is promise-less.
-      auto syncFunction = jni::static_ref_cast<JNIFunctionBody>(this->jBodyReference);
-      auto result = syncFunction->invoke(
-        react::ReadableNativeArray::newObjectCxxArgs(std::move(dynamicArray)).get()
+      return this->callSync(
+        rt,
+        moduleRegistry,
+        args,
+        count
       );
+    });
+}
 
-      if (result == nullptr) {
-        return jsi::Value::undefined();
-      }
+jsi::Value MethodMetadata::callSync(
+  jsi::Runtime &rt,
+  JSIInteropModuleRegistry *moduleRegistry,
+  const jsi::Value *args,
+  size_t count
+) {
+  if (this->jBodyReference == nullptr) {
+    return jsi::Value::undefined();
+  }
 
-      return jsi::valueFromDynamic(rt, result->cthis()->consume())
-        .asObject(rt)
-        .asArray(rt)
-        .getValueAtIndex(rt, 0);
-    });
+  JNIEnv *env = jni::Environment::current();
+
+  /**
+   * This will push a new JNI stack frame for the LocalReferences in this
+   * function call. When the stack frame for this lambda is popped,
+   * all LocalReferences are deleted.
+   */
+  jni::JniLocalScope scope(env, (int) count);
+
+  std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count,
+                                                          false);
+
+  // TODO(@lukmccall): Remove this temp array
+  auto tempArray = env->NewObjectArray(
+    convertedArgs.size(),
+    CachedReferencesRegistry::instance()->getJClass("java/lang/Object").clazz,
+    nullptr
+  );
+  for (size_t i = 0; i < convertedArgs.size(); i++) {
+    env->SetObjectArrayElement(tempArray, i, convertedArgs[i].l);
+  }
+
+  // Cast in this place is safe, cause we know that this function is promise-less.
+  auto syncFunction = jni::static_ref_cast<JNIFunctionBody>(this->jBodyReference);
+  auto result = syncFunction->invoke(
+    tempArray
+  );
+
+  if (result == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  return jsi::valueFromDynamic(rt, result->cthis()->consume())
+    .asObject(rt)
+    .asArray(rt)
+    .getValueAtIndex(rt, 0);
 }
 
 jsi::Function MethodMetadata::toAsyncFunction(
-  jsi::Runtime &runtime, 
+  jsi::Runtime &runtime,
   JSIInteropModuleRegistry *moduleRegistry
 ) {
   return jsi::Function::createFromHostFunction(
@@ -141,17 +261,22 @@ jsi::Function MethodMetadata::toAsyncFunction(
       const jsi::Value *args,
       size_t count
     ) -> jsi::Value {
-      auto dynamicArray = folly::dynamic::array();
-      for (int i = 0; i < count; i++) {
-        auto &arg = args[i];
-        dynamicArray.push_back(jsi::dynamicFromValue(rt, arg));
-      }
+      JNIEnv *env = jni::Environment::current();
+
+      /**
+       * This will push a new JNI stack frame for the LocalReferences in this
+       * function call. When the stack frame for this lambda is popped,
+       * all LocalReferences are deleted.
+       */
+      jni::JniLocalScope scope(env, (int) count);
+      std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count,
+                                                              true);
 
       auto Promise = rt.global().getPropertyAsFunction(rt, "Promise");
       // Creates a JSI promise
       jsi::Value promise = Promise.callAsConstructor(
         rt,
-        createPromiseBody(rt, moduleRegistry, std::move(dynamicArray))
+        createPromiseBody(rt, moduleRegistry, std::move(convertedArgs))
       );
       return promise;
     }
@@ -161,7 +286,7 @@ jsi::Function MethodMetadata::toAsyncFunction(
 jsi::Function MethodMetadata::createPromiseBody(
   jsi::Runtime &runtime,
   JSIInteropModuleRegistry *moduleRegistry,
-  folly::dynamic &&args
+  std::vector<jvalue> &&args
 ) {
   return jsi::Function::createFromHostFunction(
     runtime,
@@ -195,25 +320,36 @@ jsi::Function MethodMetadata::createPromiseBody(
 
       JNIEnv *env = jni::Environment::current();
 
-      jclass jPromiseImpl =
-        env->FindClass("com/facebook/react/bridge/PromiseImpl");
-      jmethodID jPromiseImplConstructor = env->GetMethodID(
-        jPromiseImpl,
+      auto &jPromise = CachedReferencesRegistry::instance()->getJClass(
+        "com/facebook/react/bridge/PromiseImpl");
+      jmethodID jPromiseConstructor = jPromise.getMethod(
         "<init>",
-        "(Lcom/facebook/react/bridge/Callback;Lcom/facebook/react/bridge/Callback;)V");
+        "(Lcom/facebook/react/bridge/Callback;Lcom/facebook/react/bridge/Callback;)V"
+      );
 
       // Creates a promise object
       jobject promise = env->NewObject(
-        jPromiseImpl,
-        jPromiseImplConstructor,
+        jPromise.clazz,
+        jPromiseConstructor,
         resolve,
         reject
       );
 
+      auto argsSize = args.size();
+      // TODO(@lukmccall): Remove this temp array
+      auto tempArray = env->NewObjectArray(
+        argsSize,
+        CachedReferencesRegistry::instance()->getJClass("java/lang/Object").clazz,
+        nullptr
+      );
+      for (size_t i = 0; i < argsSize; i++) {
+        env->SetObjectArrayElement(tempArray, i, args[i].l);
+      }
+
       // Cast in this place is safe, cause we know that this function expects promise.
       auto asyncFunction = jni::static_ref_cast<JNIAsyncFunctionBody>(this->jBodyReference);
       asyncFunction->invoke(
-        react::ReadableNativeArray::newObjectCxxArgs(args).get(),
+        tempArray,
         promise
       );
 
@@ -222,6 +358,11 @@ jsi::Function MethodMetadata::createPromiseBody(
       // the ownership to the `JNIAsyncFunctionBody`.
       env->DeleteLocalRef(promise);
 
+      for (const auto &arg: args) {
+        env->DeleteGlobalRef(arg.l);
+      }
+      env->DeleteLocalRef(tempArray);
+
       return jsi::Value::undefined();
     }
   );

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

@@ -17,6 +17,20 @@ namespace react = facebook::react;
 namespace expo {
 class JSIInteropModuleRegistry;
 
+/**
+ * A cpp version of the `expo.modules.kotlin.jni.CppType` enum.
+ * Used to determine which representation of the js value should be sent to the Kotlin.
+ */
+enum CppType {
+  DOUBLE = 1 << 0,
+  BOOLEAN = 1 << 1,
+  STRING = 1 << 2,
+  JS_OBJECT = 1 << 3,
+  JS_VALUE = 1 << 4,
+  READABLE_ARRAY = 1 << 5,
+  READABLE_MAP = 1 << 6
+};
+
 /**
  * A class that holds information about the exported function.
  */
@@ -35,22 +49,29 @@ public:
    */
   bool isAsync;
 
+  std::unique_ptr<int[]> desiredTypes;
+
   MethodMetadata(
     std::string name,
     int args,
     bool isAsync,
+    std::unique_ptr<int[]> desiredTypes,
     jni::global_ref<jobject> &&jBodyReference
   );
 
   // We deleted the copy contractor to not deal with transforming the ownership of the `jBodyReference`.
   MethodMetadata(const MethodMetadata &) = delete;
 
+  MethodMetadata(MethodMetadata &&other) = default;
+
   /**
    * MethodMetadata owns the only reference to the Kotlin function.
    * We have to clean that, cause it's a `global_ref`.
    */
   ~MethodMetadata() {
-    jBodyReference.release();
+    if (jBodyReference != nullptr) {
+      jBodyReference.release();
+    }
   }
 
   /**
@@ -65,6 +86,16 @@ public:
     JSIInteropModuleRegistry *moduleRegistry
   );
 
+  /**
+   * Calls the underlying Kotlin function.
+   */
+  jsi::Value callSync(
+    jsi::Runtime &rt,
+    JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value *args,
+    size_t count
+  );
+
 private:
   /**
    * Reference to one of two java objects - `JNIFunctionBody` or `JNIAsyncFunctionBody`.
@@ -79,14 +110,23 @@ private:
    */
   std::shared_ptr<jsi::Function> body = nullptr;
 
-  jsi::Function toSyncFunction(jsi::Runtime &runtime);
+  jsi::Function toSyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
 
   jsi::Function toAsyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
 
   jsi::Function createPromiseBody(
     jsi::Runtime &runtime,
     JSIInteropModuleRegistry *moduleRegistry,
-    folly::dynamic &&args
+    std::vector<jvalue> &&args
+  );
+
+  std::vector<jvalue> convertJSIArgsToJNI(
+    JSIInteropModuleRegistry *moduleRegistry,
+    JNIEnv *env,
+    jsi::Runtime &rt,
+    const jsi::Value *args,
+    size_t count,
+    bool returnGlobalReferences
   );
 };
 } // namespace expo