expo-modules-core 1.2.7 → 1.3.0

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

@@ -6,6 +6,7 @@
 #include "JSITypeConverter.h"
 #include "JavaScriptRuntime.h"
 #include "WeakRuntimeHolder.h"
+#include "JNIFunctionBody.h"
 
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
@@ -18,6 +19,8 @@ namespace jsi = facebook::jsi;
 namespace expo {
 class JavaScriptValue;
 
+class JavaScriptFunction;
+
 /**
  * Represents any JavaScript object. Its purpose is to exposes `jsi::Object` API back to Kotlin.
  */
@@ -61,6 +64,17 @@ public:
 
   static jsi::Object preparePropertyDescriptor(jsi::Runtime &jsRuntime, int options);
 
+  static void defineProperty(
+    jsi::Runtime &runtime,
+    jsi::Object *jsthis,
+    const std::string &name,
+    jsi::Object descriptor
+  );
+
+  void defineNativeDeallocator(
+    jni::alias_ref<JNIFunctionBody::javaobject> deallocator
+  );
+
 protected:
   WeakRuntimeHolder runtimeHolder;
   std::shared_ptr<jsi::Object> jsObject;
@@ -76,6 +90,8 @@ private:
 
   jni::local_ref<jni::JArrayClass<jstring>> jniGetPropertyNames();
 
+  jni::local_ref<jni::HybridClass<JavaScriptFunction>::javaobject> jniAsFunction();
+
   /**
    * Unsets property with the given name.
    */
@@ -114,21 +130,9 @@ private:
     jsi::Runtime &jsRuntime = runtimeHolder.getJSRuntime();
 
     auto cName = name->toStdString();
-    jsi::Object global = jsRuntime.global();
-    jsi::Object objectClass = global.getPropertyAsObject(jsRuntime, "Object");
-    jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(
-      jsRuntime,
-      "defineProperty"
-    );
     jsi::Object descriptor = preparePropertyDescriptor(jsRuntime, options);
-
     descriptor.setProperty(jsRuntime, "value", jsi_type_converter<T>::convert(jsRuntime, value));
-
-    definePropertyFunction.callWithThis(jsRuntime, objectClass, {
-      jsi::Value(jsRuntime, *jsObject),
-      jsi::String::createFromUtf8(jsRuntime, cName),
-      std::move(descriptor)
-    });
+    JavaScriptObject::defineProperty(jsRuntime, jsObject.get(), cName, std::move(descriptor));
   }
 };
 } // namespace expo

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

@@ -4,6 +4,7 @@
 #include "JavaScriptValue.h"
 #include "JavaScriptObject.h"
 #include "Exceptions.h"
+#include "JavaScriptRuntime.h"
 
 #if UNIT_TEST
 
@@ -37,9 +38,12 @@ void SyncCallInvoker::invokeSync(std::function<void()> &&func) {
   func();
 }
 
-JavaScriptRuntime::JavaScriptRuntime()
+JavaScriptRuntime::JavaScriptRuntime(
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry
+)
   : jsInvoker(std::make_shared<SyncCallInvoker>()),
-    nativeInvoker(std::make_shared<SyncCallInvoker>()) {
+    nativeInvoker(std::make_shared<SyncCallInvoker>()),
+    jsiInteropModuleRegistry(jsiInteropModuleRegistry) {
 #if !UNIT_TEST
   throw std::logic_error(
     "The JavaScriptRuntime constructor is only avaiable when UNIT_TEST is defined.");
@@ -100,10 +104,12 @@ JavaScriptRuntime::JavaScriptRuntime()
 }
 
 JavaScriptRuntime::JavaScriptRuntime(
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
   jsi::Runtime *runtime,
   std::shared_ptr<react::CallInvoker> jsInvoker,
   std::shared_ptr<react::CallInvoker> nativeInvoker
-) : jsInvoker(std::move(jsInvoker)), nativeInvoker(std::move(nativeInvoker)) {
+) : jsInvoker(std::move(jsInvoker)), nativeInvoker(std::move(nativeInvoker)),
+    jsiInteropModuleRegistry(jsiInteropModuleRegistry) {
   // Creating a shared pointer that points to the runtime but doesn't own it, thus doesn't release it.
   // In this code flow, the runtime should be owned by something else like the CatalystInstance.
   // See explanation for constructor (8): https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
@@ -178,4 +184,7 @@ std::shared_ptr<jsi::Object> JavaScriptRuntime::getMainObject() {
   return mainObject;
 }
 
+JSIInteropModuleRegistry *JavaScriptRuntime::getModuleRegistry() {
+  return jsiInteropModuleRegistry;
+}
 } // namespace expo

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

@@ -15,6 +15,8 @@ class JavaScriptValue;
 
 class JavaScriptObject;
 
+class JSIInteropModuleRegistry;
+
 /**
  * Dummy CallInvoker that invokes everything immediately.
  * Used in the test environment to check the async flow.
@@ -42,9 +44,12 @@ public:
    * Initializes a runtime that is independent from React Native and its runtime initialization.
    * This flow is mostly intended for tests. The JS call invoker is set to `SyncCallInvoker`.
    */
-  JavaScriptRuntime();
+  JavaScriptRuntime(
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry
+  );
 
   JavaScriptRuntime(
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
     jsi::Runtime *runtime,
     std::shared_ptr<react::CallInvoker> jsInvoker,
     std::shared_ptr<react::CallInvoker> nativeInvoker
@@ -83,9 +88,12 @@ public:
   std::shared_ptr<react::CallInvoker> nativeInvoker;
 
   std::shared_ptr<jsi::Object> getMainObject();
+
+  JSIInteropModuleRegistry *getModuleRegistry();
 private:
   std::shared_ptr<jsi::Runtime> runtime;
   std::shared_ptr<jsi::Object> mainObject;
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry;
 
   void installMainObject();
 };

package/android/src/main/cpp/JavaScriptValue.cpp

@@ -5,6 +5,7 @@
 #include "JavaScriptRuntime.h"
 #include "JavaScriptObject.h"
 #include "JavaScriptTypedArray.h"
+#include "JavaScriptFunction.h"
 #include "TypedArray.h"
 #include "Exceptions.h"
 
@@ -28,6 +29,7 @@ void JavaScriptValue::registerNatives() {
                    makeNativeMethod("getObject", JavaScriptValue::getObject),
                    makeNativeMethod("getArray", JavaScriptValue::getArray),
                    makeNativeMethod("getTypedArray", JavaScriptValue::getTypedArray),
+                   makeNativeMethod("jniGetFunction", JavaScriptValue::jniGetFunction),
                  });
 }
 
@@ -156,6 +158,13 @@ jni::local_ref<JavaScriptObject::javaobject> JavaScriptValue::getObject() {
   return JavaScriptObject::newObjectCxxArgs(runtimeHolder, jsObject);
 }
 
+jni::local_ref<JavaScriptFunction::javaobject> JavaScriptValue::jniGetFunction() {
+  auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto jsFunction = std::make_shared<jsi::Function>(
+    jsValue->getObject(jsRuntime).asFunction(jsRuntime));
+  return JavaScriptFunction::newObjectCxxArgs(runtimeHolder, jsFunction);
+}
+
 jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptValue::getArray() {
   auto &jsRuntime = runtimeHolder.getJSRuntime();
 

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

@@ -21,6 +21,8 @@ class JavaScriptObject;
 
 class JavaScriptTypedArray;
 
+class JavaScriptFunction;
+
 /**
  * Represents any JavaScript value. Its purpose is to expose the `jsi::Value` API back to Kotlin.
  */
@@ -78,6 +80,8 @@ public:
 
   jni::local_ref<JavaScriptTypedArray::javaobject> getTypedArray();
 
+  jni::local_ref<jni::HybridClass<JavaScriptFunction>::javaobject> jniGetFunction();
+
 private:
   friend HybridBase;
 

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

@@ -6,13 +6,11 @@
 #include "JavaReferencesCache.h"
 #include "Exceptions.h"
 #include "JavaCallback.h"
+#include "types/JNIToJSIConverter.h"
 
 #include <utility>
+#include <functional>
 
-#include <react/jni/ReadableNativeMap.h>
-#include <react/jni/ReadableNativeArray.h>
-#include <react/jni/WritableNativeArray.h>
-#include <react/jni/WritableNativeMap.h>
 #include "JSReferencesCache.h"
 
 namespace jni = facebook::jni;
@@ -25,18 +23,12 @@ namespace expo {
 // https://github.com/facebook/react-native/blob/7dceb9b63c0bfd5b13bf6d26f9530729506e9097/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp#L57
 jni::local_ref<JavaCallback::JavaPart> createJavaCallbackFromJSIFunction(
   jsi::Function &&function,
-  std::weak_ptr<react::LongLivedObjectCollection> longLivedObjectCollection,
   jsi::Runtime &rt,
   JSIInteropModuleRegistry *moduleRegistry,
   bool isRejectCallback = false
 ) {
   std::shared_ptr<react::CallInvoker> jsInvoker = moduleRegistry->runtimeHolder->jsInvoker;
-  auto strongLongLiveObjectCollection = longLivedObjectCollection.lock();
-  if (!strongLongLiveObjectCollection) {
-    throw std::runtime_error("The LongLivedObjectCollection for MethodMetadata is not alive.");
-  }
-  auto weakWrapper = react::CallbackWrapper::createWeak(strongLongLiveObjectCollection,
-                                                        std::move(function), rt,
+  auto weakWrapper = react::CallbackWrapper::createWeak(std::move(function), rt,
                                                         std::move(jsInvoker));
 
   // This needs to be a shared_ptr because:
@@ -117,9 +109,25 @@ jobjectArray MethodMetadata::convertJSIArgsToJNI(
   JSIInteropModuleRegistry *moduleRegistry,
   JNIEnv *env,
   jsi::Runtime &rt,
+  const jsi::Value &thisValue,
   const jsi::Value *args,
   size_t count
 ) {
+  // This function takes the owner, so the args number is higher because we have access to the thisValue.
+  if (takesOwner) {
+    count++;
+  }
+
+  // The `count < this->args` case is handled by the Kotlin part
+  if (count > this->args) {
+    throwNewJavaException(
+      InvalidArgsNumberException::create(
+        count,
+        this->args
+      ).get()
+    );
+  }
+
   auto argumentArray = env->NewObjectArray(
     count,
     JavaReferencesCache::instance()->getJClass("java/lang/Object").clazz,
@@ -128,8 +136,21 @@ jobjectArray MethodMetadata::convertJSIArgsToJNI(
 
   std::vector<jobject> result(count);
 
-  for (unsigned int argIndex = 0; argIndex < count; argIndex++) {
-    const jsi::Value &arg = args[argIndex];
+  const auto getCurrentArg = [&thisValue, args, takesOwner = takesOwner](
+    size_t index
+  ) -> const jsi::Value & {
+    if (!takesOwner) {
+      return args[index];
+    } else {
+      if (index != 0) {
+        return args[index - 1];
+      }
+      return thisValue;
+    }
+  };
+
+  for (size_t argIndex = 0; argIndex < count; argIndex++) {
+    const jsi::Value &arg = getCurrentArg(argIndex);
     auto &type = argTypes[argIndex];
     if (arg.isNull() || arg.isUndefined()) {
       // If value is null or undefined, we just passes a null
@@ -154,17 +175,17 @@ jobjectArray MethodMetadata::convertJSIArgsToJNI(
 }
 
 MethodMetadata::MethodMetadata(
-  std::weak_ptr<react::LongLivedObjectCollection> longLivedObjectCollection,
   std::string name,
+  bool takesOwner,
   int args,
   bool isAsync,
   jni::local_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
   jni::global_ref<jobject> &&jBodyReference
 ) : name(std::move(name)),
+    takesOwner(takesOwner),
     args(args),
     isAsync(isAsync),
-    jBodyReference(std::move(jBodyReference)),
-    longLivedObjectCollection_(std::move(longLivedObjectCollection)) {
+    jBodyReference(std::move(jBodyReference)) {
   argTypes.reserve(args);
   for (size_t i = 0; i < args; i++) {
     auto expectedType = expectedArgTypes->getElement(i);
@@ -175,18 +196,18 @@ MethodMetadata::MethodMetadata(
 }
 
 MethodMetadata::MethodMetadata(
-  std::weak_ptr<react::LongLivedObjectCollection> longLivedObjectCollection,
   std::string name,
+  bool takesOwner,
   int args,
   bool isAsync,
   std::vector<std::unique_ptr<AnyType>> &&expectedArgTypes,
   jni::global_ref<jobject> &&jBodyReference
 ) : name(std::move(name)),
+    takesOwner(takesOwner),
     args(args),
     isAsync(isAsync),
     argTypes(std::move(expectedArgTypes)),
-    jBodyReference(std::move(jBodyReference)),
-    longLivedObjectCollection_(std::move(longLivedObjectCollection)) {
+    jBodyReference(std::move(jBodyReference)) {
 }
 
 std::shared_ptr<jsi::Function> MethodMetadata::toJSFunction(
@@ -222,6 +243,7 @@ jsi::Function MethodMetadata::toSyncFunction(
         return this->callSync(
           rt,
           moduleRegistry,
+          thisValue,
           args,
           count
         );
@@ -231,26 +253,19 @@ jsi::Function MethodMetadata::toSyncFunction(
     });
 }
 
-jsi::Value MethodMetadata::callSync(
+jni::local_ref<jobject> MethodMetadata::callJNISync(
+  JNIEnv *env,
   jsi::Runtime &rt,
   JSIInteropModuleRegistry *moduleRegistry,
+  const jsi::Value &thisValue,
   const jsi::Value *args,
   size_t count
 ) {
   if (this->jBodyReference == nullptr) {
-    return jsi::Value::undefined();
+    return nullptr;
   }
 
-  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);
-
-  auto convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count);
+  auto convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, thisValue, args, count);
 
   // Cast in this place is safe, cause we know that this function is promise-less.
   auto syncFunction = jni::static_ref_cast<JNIFunctionBody>(this->jBodyReference);
@@ -259,60 +274,26 @@ jsi::Value MethodMetadata::callSync(
   );
 
   env->DeleteLocalRef(convertedArgs);
-  if (result == nullptr) {
-    return jsi::Value::undefined();
-  }
-  auto unpackedResult = result.get();
-  auto cache = JavaReferencesCache::instance();
-  if (env->IsInstanceOf(unpackedResult, cache->getJClass("java/lang/Double").clazz)) {
-    return {jni::static_ref_cast<jni::JDouble>(result)->value()};
-  }
-  if (env->IsInstanceOf(unpackedResult, cache->getJClass("java/lang/Integer").clazz)) {
-    return {jni::static_ref_cast<jni::JInteger>(result)->value()};
-  }
-  if (env->IsInstanceOf(unpackedResult, cache->getJClass("java/lang/Long").clazz)) {
-    return {(double) jni::static_ref_cast<jni::JLong>(result)->value()};
-  }
-  if (env->IsInstanceOf(unpackedResult, cache->getJClass("java/lang/String").clazz)) {
-    return jsi::String::createFromUtf8(
-      rt,
-      jni::static_ref_cast<jni::JString>(result)->toStdString()
-    );
-  }
-  if (env->IsInstanceOf(unpackedResult, cache->getJClass("java/lang/Boolean").clazz)) {
-    return {(bool) jni::static_ref_cast<jni::JBoolean>(result)->value()};
-  }
-  if (env->IsInstanceOf(unpackedResult, cache->getJClass("java/lang/Float").clazz)) {
-    return {(double) jni::static_ref_cast<jni::JFloat>(result)->value()};
-  }
-  if (env->IsInstanceOf(
-    unpackedResult,
-    cache->getJClass("com/facebook/react/bridge/WritableNativeArray").clazz
-  )) {
-    auto dynamic = jni::static_ref_cast<react::WritableNativeArray::javaobject>(result)
-      ->cthis()
-      ->consume();
-    return jsi::valueFromDynamic(rt, dynamic);
-  }
-  if (env->IsInstanceOf(
-    unpackedResult,
-    cache->getJClass("com/facebook/react/bridge/WritableNativeMap").clazz
-  )) {
-    auto dynamic = jni::static_ref_cast<react::WritableNativeMap::javaobject>(result)
-      ->cthis()
-      ->consume();
-    return jsi::valueFromDynamic(rt, dynamic);
-  }
-  if (env->IsInstanceOf(unpackedResult, JavaScriptModuleObject::javaClassStatic().get())) {
-    auto anonymousObject = jni::static_ref_cast<JavaScriptModuleObject::javaobject>(result)
-      ->cthis();
-    anonymousObject->jsiInteropModuleRegistry = moduleRegistry;
-    auto hostObject = std::make_shared<JavaScriptModuleObject::HostObject>(anonymousObject);
-    hostObject->jObjectRef = jni::make_global(result);
-    return jsi::Object::createFromHostObject(rt, hostObject);
-  }
+  return result;
+}
+
+jsi::Value MethodMetadata::callSync(
+  jsi::Runtime &rt,
+  JSIInteropModuleRegistry *moduleRegistry,
+  const jsi::Value &thisValue,
+  const jsi::Value *args,
+  size_t count
+) {
+  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);
 
-  return jsi::Value::undefined();
+  auto result = this->callJNISync(env, rt, moduleRegistry, thisValue, args, count);
+  return convert(moduleRegistry, env, rt, std::move(result));
 }
 
 jsi::Function MethodMetadata::toAsyncFunction(
@@ -343,7 +324,7 @@ jsi::Function MethodMetadata::toAsyncFunction(
       );
 
       try {
-        auto convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count);
+        auto convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, thisValue, args, count);
         auto globalConvertedArgs = (jobjectArray) env->NewGlobalRef(convertedArgs);
         env->DeleteLocalRef(convertedArgs);
 
@@ -423,14 +404,12 @@ jsi::Function MethodMetadata::createPromiseBody(
 
       jobject resolve = createJavaCallbackFromJSIFunction(
         std::move(resolveJSIFn),
-        longLivedObjectCollection_,
         rt,
         moduleRegistry
       ).release();
 
       jobject reject = createJavaCallbackFromJSIFunction(
         std::move(rejectJSIFn),
-        longLivedObjectCollection_,
         rt,
         moduleRegistry,
         true

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

@@ -9,7 +9,6 @@
 #include <jsi/jsi.h>
 #include <fbjni/fbjni.h>
 #include <ReactCommon/TurboModuleUtils.h>
-#include <react/bridging/LongLivedObject.h>
 #include <react/jni/ReadableNativeArray.h>
 #include <memory>
 #include <vector>
@@ -32,11 +31,15 @@ public:
    * Function name
    */
   std::string name;
+  /**
+   * Whether this function takes owner
+   */
+  bool takesOwner;
   /**
    * Number of arguments
    */
   int args;
-  /*
+  /**
    * Whether this function is async
    */
   bool isAsync;
@@ -46,8 +49,8 @@ public:
   std::vector<std::unique_ptr<AnyType>> argTypes;
 
   MethodMetadata(
-    std::weak_ptr<react::LongLivedObjectCollection> longLivedObjectCollection,
     std::string name,
+    bool takesOwner,
     int args,
     bool isAsync,
     jni::local_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
@@ -55,8 +58,8 @@ public:
   );
 
   MethodMetadata(
-    std::weak_ptr<react::LongLivedObjectCollection> longLivedObjectCollection,
     std::string name,
+    bool takesOwner,
     int args,
     bool isAsync,
     std::vector<std::unique_ptr<AnyType>> &&expectedArgTypes,
@@ -68,16 +71,6 @@ public:
 
   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() {
-    if (jBodyReference != nullptr) {
-      jBodyReference.release();
-    }
-  }
-
   /**
    * Transforms metadata to a jsi::Function.
    *
@@ -96,6 +89,16 @@ public:
   jsi::Value callSync(
     jsi::Runtime &rt,
     JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value &thisValue,
+    const jsi::Value *args,
+    size_t count
+  );
+
+  jni::local_ref<jobject> callJNISync(
+    JNIEnv *env,
+    jsi::Runtime &rt,
+    JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value &thisValue,
     const jsi::Value *args,
     size_t count
   );
@@ -114,8 +117,6 @@ private:
    */
   std::shared_ptr<jsi::Function> body = nullptr;
 
-  std::weak_ptr<react::LongLivedObjectCollection> longLivedObjectCollection_;
-
   jsi::Function toSyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
 
   jsi::Function toAsyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
@@ -130,6 +131,7 @@ private:
     JSIInteropModuleRegistry *moduleRegistry,
     JNIEnv *env,
     jsi::Runtime &rt,
+    const jsi::Value &thisValue,
     const jsi::Value *args,
     size_t count
   );

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

@@ -0,0 +1,25 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+class JSI_EXPORT ObjectDeallocator : public jsi::HostObject {
+public:
+  typedef std::function<void()> ObjectDeallocatorType;
+
+  ObjectDeallocator(ObjectDeallocatorType deallocator) : deallocator(deallocator) {};
+
+  virtual ~ObjectDeallocator() {
+    deallocator();
+  }
+
+  const ObjectDeallocatorType deallocator;
+
+}; // class ObjectDeallocator
+
+}

package/android/src/main/cpp/WeakRuntimeHolder.cpp

@@ -1,5 +1,6 @@
 #include "WeakRuntimeHolder.h"
 #include "JavaScriptRuntime.h"
+#include "JSIInteropModuleRegistry.h"
 
 namespace expo {
 WeakRuntimeHolder::WeakRuntimeHolder(std::weak_ptr<JavaScriptRuntime> runtime)
@@ -14,4 +15,10 @@ jsi::Runtime &WeakRuntimeHolder::getJSRuntime() {
 void WeakRuntimeHolder::ensureRuntimeIsValid() {
   assert((!expired()) && "JS Runtime was used after deallocation");
 }
+
+JSIInteropModuleRegistry *WeakRuntimeHolder::getModuleRegistry() {
+  auto runtime = lock();
+  assert((runtime != nullptr) && "JS Runtime was used after deallocation");
+  return runtime->getModuleRegistry();
+}
 } // namespace expo

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

@@ -12,6 +12,8 @@ namespace jsi = facebook::jsi;
 
 class JavaScriptRuntime;
 
+class JSIInteropModuleRegistry;
+
 /**
  * A convenient class to access underlying jni::Runtime and hold a weak reference to expo::JavaScriptRuntime.
  * It's working like std::weak_ptr but can have more helper methods.
@@ -31,6 +33,8 @@ public:
    */
   jsi::Runtime &getJSRuntime();
 
+  JSIInteropModuleRegistry *getModuleRegistry();
+
   void ensureRuntimeIsValid();
 };
 } // namespace expo

package/android/src/main/cpp/types/CppType.h

@@ -22,6 +22,9 @@ enum CppType {
   TYPED_ARRAY = 1 << 10,
   PRIMITIVE_ARRAY = 1 << 11,
   LIST = 1 << 12,
-  MAP = 1 << 13
+  MAP = 1 << 13,
+  VIEW_TAG = 1 << 14,
+  SHARED_OBJECT_ID = 1 << 15,
+  JS_FUNCTION = 1 << 16
 };
 } // namespace expo