expo-modules-core 1.2.6 → 1.3.0

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

@@ -2,6 +2,7 @@
 
 #include "JavaScriptModuleObject.h"
 #include "JSIInteropModuleRegistry.h"
+#include "ObjectDeallocator.h"
 
 #include <folly/dynamic.h>
 #include <jsi/JSIDynamic.h>
@@ -16,6 +17,7 @@
 #include <utility>
 #include <tuple>
 #include <algorithm>
+#include <sstream>
 
 namespace jni = facebook::jni;
 namespace jsi = facebook::jsi;
@@ -23,6 +25,60 @@ namespace react = facebook::react;
 
 namespace expo {
 
+void decorateObjectWithFunctions(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  jsi::Object *jsObject,
+  JavaScriptModuleObject *objectData) {
+  for (auto &[name, method]: objectData->methodsMetadata) {
+    jsObject->setProperty(
+      runtime,
+      jsi::String::createFromUtf8(runtime, name),
+      jsi::Value(runtime, *method.toJSFunction(runtime, jsiInteropModuleRegistry))
+    );
+  }
+}
+
+void decorateObjectWithProperties(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  jsi::Object *jsObject,
+  JavaScriptModuleObject *objectData) {
+  for (auto &[name, property]: objectData->properties) {
+    auto &[getter, setter] = property;
+
+    auto descriptor = JavaScriptObject::preparePropertyDescriptor(runtime,
+                                                                  1 << 1 /* enumerable */);
+    descriptor.setProperty(
+      runtime,
+      "get",
+      jsi::Value(runtime, *getter.toJSFunction(runtime,
+                                               jsiInteropModuleRegistry))
+    );
+    descriptor.setProperty(
+      runtime,
+      "set",
+      jsi::Value(runtime, *setter.toJSFunction(runtime,
+                                               jsiInteropModuleRegistry))
+    );
+    JavaScriptObject::defineProperty(runtime, jsObject, name, std::move(descriptor));
+  }
+}
+
+void decorateObjectWithConstants(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  jsi::Object *jsObject,
+  JavaScriptModuleObject *objectData) {
+  for (const auto &[name, value]: objectData->constants) {
+    jsObject->setProperty(
+      runtime,
+      jsi::String::createFromUtf8(runtime, name),
+      jsi::valueFromDynamic(runtime, value)
+    );
+  }
+}
+
 jni::local_ref<jni::HybridClass<JavaScriptModuleObject>::jhybriddata>
 JavaScriptModuleObject::initHybrid(jni::alias_ref<jhybridobject> jThis) {
   return makeCxxInstance(jThis);
@@ -38,6 +94,10 @@ void JavaScriptModuleObject::registerNatives() {
                                     JavaScriptModuleObject::registerAsyncFunction),
                    makeNativeMethod("registerProperty",
                                     JavaScriptModuleObject::registerProperty),
+                   makeNativeMethod("registerClass",
+                                    JavaScriptModuleObject::registerClass),
+                   makeNativeMethod("registerViewPrototype",
+                                    JavaScriptModuleObject::registerViewPrototype)
                  });
 }
 
@@ -46,11 +106,133 @@ std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &
     return object;
   }
 
-  auto hostObject = std::make_shared<JavaScriptModuleObject::HostObject>(this);
-  auto object = std::make_shared<jsi::Object>(
-    jsi::Object::createFromHostObject(runtime, hostObject));
-  jsiObject = object;
-  return object;
+  auto moduleObject = std::make_shared<jsi::Object>(runtime);
+
+  decorateObjectWithConstants(
+    runtime,
+    jsiInteropModuleRegistry,
+    moduleObject.get(),
+    this
+  );
+  decorateObjectWithProperties(
+    runtime,
+    jsiInteropModuleRegistry,
+    moduleObject.get(),
+    this
+  );
+  decorateObjectWithFunctions(
+    runtime,
+    jsiInteropModuleRegistry,
+    moduleObject.get(),
+    this
+  );
+
+  if (viewPrototype) {
+    auto viewPrototypeObject = viewPrototype->cthis();
+    viewPrototypeObject->jsiInteropModuleRegistry = jsiInteropModuleRegistry;
+    auto viewPrototypeJSIObject = viewPrototypeObject->getJSIObject(runtime);
+    moduleObject->setProperty(
+      runtime,
+      "ViewPrototype",
+      jsi::Value(runtime, *viewPrototypeJSIObject)
+    );
+  }
+
+  for (auto &[name, classInfo]: classes) {
+    auto &[classRef, constructor] = classInfo;
+    auto classObject = classRef->cthis();
+    classObject->jsiInteropModuleRegistry = jsiInteropModuleRegistry;
+
+    std::string nativeConstructorKey("__native_constructor__");
+
+    // Create a string buffer of the source code to evaluate.
+    std::stringstream source;
+    source << "(function " << name << "(...args) { this." << nativeConstructorKey
+           << "(...args); return this; })";
+    std::shared_ptr<jsi::StringBuffer> sourceBuffer = std::make_shared<jsi::StringBuffer>(
+      source.str());
+
+    // Evaluate the code and obtain returned value (the constructor function).
+    jsi::Object klass = runtime.evaluateJavaScript(sourceBuffer, "").asObject(runtime);
+
+    // Set the native constructor in the prototype.
+    jsi::Object prototype = klass.getPropertyAsObject(runtime, "prototype");
+    jsi::PropNameID nativeConstructorPropId = jsi::PropNameID::forAscii(runtime,
+                                                                        nativeConstructorKey);
+    jsi::Function nativeConstructor = jsi::Function::createFromHostFunction(
+      runtime,
+      nativeConstructorPropId,
+      // The paramCount is not obligatory to match, it only affects the `length` property of the function.
+      0,
+      [classObject, &constructor = constructor, jsiInteropModuleRegistry = jsiInteropModuleRegistry](
+        jsi::Runtime &runtime,
+        const jsi::Value &thisValue,
+        const jsi::Value *args,
+        size_t count
+      ) -> jsi::Value {
+        auto thisObject = std::make_shared<jsi::Object>(thisValue.asObject(runtime));
+        decorateObjectWithProperties(runtime, jsiInteropModuleRegistry, thisObject.get(),
+                                     classObject);
+        try {
+          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 result = constructor.callJNISync(
+            env,
+            runtime,
+            jsiInteropModuleRegistry,
+            thisValue,
+            args,
+            count
+          );
+          if (result == nullptr) {
+            return jsi::Value::undefined();
+          }
+          jobject unpackedResult = result.get();
+          jclass resultClass = env->GetObjectClass(unpackedResult);
+          if (env->IsAssignableFrom(
+            resultClass,
+            JavaReferencesCache::instance()->getJClass(
+              "expo/modules/kotlin/sharedobjects/SharedObject").clazz
+          )) {
+            auto jsThisObject = JavaScriptObject::newObjectCxxArgs(
+              jsiInteropModuleRegistry->runtimeHolder,
+              thisObject
+            );
+            jsiInteropModuleRegistry->registerSharedObject(result, jsThisObject);
+          }
+        } catch (jni::JniException &jniException) {
+          rethrowAsCodedError(runtime, jniException);
+        }
+        return jsi::Value::undefined();
+      });
+
+    auto descriptor = JavaScriptObject::preparePropertyDescriptor(runtime, 0);
+    descriptor.setProperty(runtime, "value", jsi::Value(runtime, nativeConstructor));
+
+    JavaScriptObject::defineProperty(runtime, &prototype, nativeConstructorKey,
+                                     std::move(descriptor));
+
+    moduleObject->setProperty(
+      runtime,
+      jsi::String::createFromUtf8(runtime, name),
+      jsi::Value(runtime, klass.asFunction(runtime))
+    );
+
+    decorateObjectWithFunctions(
+      runtime,
+      jsiInteropModuleRegistry,
+      &prototype,
+      classObject
+    );
+  }
+
+  jsiObject = moduleObject;
+  return moduleObject;
 }
 
 void JavaScriptModuleObject::exportConstants(
@@ -66,6 +248,7 @@ void JavaScriptModuleObject::exportConstants(
 
 void JavaScriptModuleObject::registerSyncFunction(
   jni::alias_ref<jstring> name,
+  jboolean takesOwner,
   jint args,
   jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
   jni::alias_ref<JNIFunctionBody::javaobject> body
@@ -74,8 +257,8 @@ void JavaScriptModuleObject::registerSyncFunction(
 
   methodsMetadata.try_emplace(
     cName,
-    longLivedObjectCollection_,
     cName,
+    takesOwner,
     args,
     false,
     jni::make_local(expectedArgTypes),
@@ -85,6 +268,7 @@ void JavaScriptModuleObject::registerSyncFunction(
 
 void JavaScriptModuleObject::registerAsyncFunction(
   jni::alias_ref<jstring> name,
+  jboolean takesOwner,
   jint args,
   jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
   jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
@@ -93,8 +277,8 @@ void JavaScriptModuleObject::registerAsyncFunction(
 
   methodsMetadata.try_emplace(
     cName,
-    longLivedObjectCollection_,
     cName,
+    takesOwner,
     args,
     true,
     jni::make_local(expectedArgTypes),
@@ -102,6 +286,38 @@ void JavaScriptModuleObject::registerAsyncFunction(
   );
 }
 
+void JavaScriptModuleObject::registerClass(
+  jni::alias_ref<jstring> name,
+  jni::alias_ref<JavaScriptModuleObject::javaobject> classObject,
+  jboolean takesOwner,
+  jint args,
+  jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
+  jni::alias_ref<JNIFunctionBody::javaobject> body
+) {
+  std::string cName = name->toStdString();
+  MethodMetadata constructor(
+    "constructor",
+    takesOwner,
+    args,
+    false,
+    jni::make_local(expectedArgTypes),
+    jni::make_global(body)
+  );
+
+  auto pair = std::make_pair(jni::make_global(classObject), std::move(constructor));
+
+  classes.try_emplace(
+    cName,
+    std::move(pair)
+  );
+}
+
+void JavaScriptModuleObject::registerViewPrototype(
+  jni::alias_ref<JavaScriptModuleObject::javaobject> viewPrototype
+) {
+  this->viewPrototype = jni::make_global(viewPrototype);
+}
+
 void JavaScriptModuleObject::registerProperty(
   jni::alias_ref<jstring> name,
   jni::alias_ref<ExpectedType> expectedArgType,
@@ -111,8 +327,8 @@ void JavaScriptModuleObject::registerProperty(
   auto cName = name->toStdString();
 
   auto getterMetadata = MethodMetadata(
-    longLivedObjectCollection_,
     cName,
+    false,
     0,
     false,
     std::vector<std::unique_ptr<AnyType>>(),
@@ -122,8 +338,8 @@ void JavaScriptModuleObject::registerProperty(
   auto types = std::vector<std::unique_ptr<AnyType>>();
   types.push_back(std::make_unique<AnyType>(jni::make_local(expectedArgType)));
   auto setterMetadata = MethodMetadata(
-    longLivedObjectCollection_,
     cName,
+    false,
     1,
     false,
     std::move(types),
@@ -138,103 +354,7 @@ void JavaScriptModuleObject::registerProperty(
   properties.insert({cName, std::move(functions)});
 }
 
-JavaScriptModuleObject::HostObject::HostObject(
-  JavaScriptModuleObject *jsModule) : jsModule(jsModule) {}
-
-/**
- * Clears all the JSI references held by the `JavaScriptModuleObject`.
- */
-JavaScriptModuleObject::HostObject::~HostObject() {
-  jObjectRef.reset();
-  jsModule->jsiObject.reset();
-  jsModule->methodsMetadata.clear();
-  jsModule->constants.clear();
-  jsModule->properties.clear();
-  jsModule->longLivedObjectCollection_->clear();
-}
-
-jsi::Value JavaScriptModuleObject::HostObject::get(jsi::Runtime &runtime,
-                                                   const jsi::PropNameID &name) {
-  auto cName = name.utf8(runtime);
-
-  auto constantsRecord = jsModule->constants.find(cName);
-  if (constantsRecord != jsModule->constants.end()) {
-    auto dynamic = constantsRecord->second;
-    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();
-  }
-  auto &metadata = metadataRecord->second;
-  return jsi::Value(runtime, *metadata.toJSFunction(runtime, jsModule->jsiInteropModuleRegistry));
-}
-
-void JavaScriptModuleObject::HostObject::set(
-  jsi::Runtime &runtime,
-  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) + "'"
-  );
-}
-
-std::vector<jsi::PropNameID> JavaScriptModuleObject::HostObject::getPropertyNames(
-  jsi::Runtime &rt
-) {
-  auto &metadata = jsModule->methodsMetadata;
-  std::vector<jsi::PropNameID> result;
-  std::transform(
-    metadata.begin(),
-    metadata.end(),
-    std::back_inserter(result),
-    [&rt](const auto &kv) {
-      return jsi::PropNameID::forUtf8(rt, kv.first);
-    }
-  );
-
-  auto &constants = jsModule->constants;
-  std::transform(
-    constants.begin(),
-    constants.end(),
-    std::back_inserter(result),
-    [&rt](const auto &kv) {
-      return jsi::PropNameID::forUtf8(rt, kv.first);
-    }
-  );
-
-  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;
-}
-
 JavaScriptModuleObject::JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis)
   : javaPart_(jni::make_global(jThis)) {
-  longLivedObjectCollection_ = std::make_shared<react::LongLivedObjectCollection>();
 }
 } // namespace expo

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

@@ -4,7 +4,6 @@
 
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
-#include <react/bridging/LongLivedObject.h>
 #include <react/jni/ReadableNativeArray.h>
 #include <jni/JCallback.h>
 
@@ -21,6 +20,29 @@ namespace react = facebook::react;
 namespace expo {
 class JSIInteropModuleRegistry;
 
+class JavaScriptModuleObject;
+
+void decorateObjectWithFunctions(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  jsi::Object *jsObject,
+  JavaScriptModuleObject *objectData
+);
+
+void decorateObjectWithProperties(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  jsi::Object *jsObject,
+  JavaScriptModuleObject *objectData
+);
+
+void decorateObjectWithConstants(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  jsi::Object *jsObject,
+  JavaScriptModuleObject *objectData
+);
+
 /**
  * A CPP part of the module.
  *
@@ -60,6 +82,7 @@ public:
    */
   void registerSyncFunction(
     jni::alias_ref<jstring> name,
+    jboolean takesOwner,
     jint args,
     jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
     jni::alias_ref<JNIFunctionBody::javaobject> body
@@ -71,11 +94,25 @@ public:
    */
   void registerAsyncFunction(
     jni::alias_ref<jstring> name,
+    jboolean takesOwner,
     jint args,
     jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
     jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
   );
 
+  void registerClass(
+    jni::alias_ref<jstring> name,
+    jni::alias_ref<JavaScriptModuleObject::javaobject> classObject,
+    jboolean takesOwner,
+    jint args,
+    jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
+    jni::alias_ref<JNIFunctionBody::javaobject> body
+  );
+
+  void registerViewPrototype(
+    jni::alias_ref<JavaScriptModuleObject::javaobject> viewPrototype
+  );
+
   /**
    * Registers a property
    * @param name of the property
@@ -90,41 +127,35 @@ public:
     jni::alias_ref<JNIFunctionBody::javaobject> setter
   );
 
-  /**
-   * An inner class of the `JavaScriptModuleObject` that is exported to the JS.
-   * It's an additional communication layer between JS and Kotlin.
-   * So the high-level view on accessing the exported function will look like this:
-   * `JS` --get function--> `JavaScriptModuleObject::HostObject` --access module metadata--> `JavaScriptModuleObject`
-   *  --create JSI function--> `MethodMetadata`
-   *
-   * This abstraction wasn't necessary. However, it makes the management of ownership much easier -
-   * `JavaScriptModuleObject` is held by the ModuleHolder and `JavaScriptModuleObject::HostObject` is stored in the JS runtime.
-   * Without this distinction the `JavaScriptModuleObject` would have to turn into `HostObject` and `HybridObject` at the same time.
-   */
-  class HostObject : public jsi::HostObject {
-  public:
-    HostObject(JavaScriptModuleObject *);
-
-    ~HostObject() override;
-
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
-
-    void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) override;
-
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-
-    jni::global_ref<jobject> jObjectRef;
-  private:
-    JavaScriptModuleObject *jsModule;
-  };
-
 private:
   explicit JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis);
 
 private:
   friend HybridBase;
+
+  friend void decorateObjectWithFunctions(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    jsi::Object *jsObject,
+    JavaScriptModuleObject *objectData
+  );
+
+  friend void decorateObjectWithProperties(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    jsi::Object *jsObject,
+    JavaScriptModuleObject *objectData
+  );
+
+  friend void decorateObjectWithConstants(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    jsi::Object *jsObject,
+    JavaScriptModuleObject *objectData
+  );
+
   /**
-   * A reference to the `JavaScriptModuleObject::HostObject`.
+   * A reference to the `jsi::Object`.
    * Simple we cached that value to return the same object each time.
    * It's a weak reference because the JS runtime holds the actual object. 
    * Doing that allows the runtime to deallocate jsi::Object if it's not needed anymore.
@@ -148,9 +179,11 @@ private:
    */
   std::map<std::string, std::pair<MethodMetadata, MethodMetadata>> properties;
 
-  /**
-   * The `LongLivedObjectCollection` to hold `LongLivedObject` (callbacks or promises) for this module.
-   */
-  std::shared_ptr<react::LongLivedObjectCollection> longLivedObjectCollection_;
+  std::map<
+    std::string,
+    std::pair<jni::global_ref<JavaScriptModuleObject::javaobject>, MethodMetadata>
+  > classes;
+
+  jni::global_ref<JavaScriptModuleObject::javaobject> viewPrototype;
 };
 } // namespace expo

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

@@ -2,8 +2,11 @@
 
 #include "JavaScriptObject.h"
 #include "JavaScriptValue.h"
+#include "JavaScriptFunction.h"
 #include "JavaScriptRuntime.h"
 #include "JSITypeConverter.h"
+#include "ObjectDeallocator.h"
+#include "JavaReferencesCache.h"
 
 namespace expo {
 void JavaScriptObject::registerNatives() {
@@ -29,6 +32,8 @@ void JavaScriptObject::registerNatives() {
                                     JavaScriptObject::defineProperty<jni::alias_ref<JavaScriptValue::javaobject>>),
                    makeNativeMethod("defineJSObjectProperty",
                                     JavaScriptObject::defineProperty<jni::alias_ref<JavaScriptObject::javaobject>>),
+                   makeNativeMethod("defineNativeDeallocator",
+                                    JavaScriptObject::defineNativeDeallocator),
                  });
 }
 
@@ -99,6 +104,12 @@ jni::local_ref<jni::JArrayClass<jstring>> JavaScriptObject::jniGetPropertyNames(
   return paredResult;
 }
 
+jni::local_ref<JavaScriptFunction::javaobject> JavaScriptObject::jniAsFunction() {
+  auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto jsFuncion = std::make_shared<jsi::Function>(jsObject->asFunction(jsRuntime));
+  return JavaScriptFunction::newObjectCxxArgs(runtimeHolder, jsFuncion);
+}
+
 void JavaScriptObject::setProperty(const std::string &name, jsi::Value value) {
   auto &jsRuntime = runtimeHolder.getJSRuntime();
   jsObject->setProperty(jsRuntime, name.c_str(), value);
@@ -121,7 +132,50 @@ jsi::Object JavaScriptObject::preparePropertyDescriptor(
   jsi::Object descriptor(jsRuntime);
   descriptor.setProperty(jsRuntime, "configurable", (bool) ((1 << 0) & options));
   descriptor.setProperty(jsRuntime, "enumerable", (bool) ((1 << 1) & options));
-  descriptor.setProperty(jsRuntime, "writable", (bool) ((1 << 2) & options));
+  if ((bool) (1 << 2 & options)) {
+    descriptor.setProperty(jsRuntime, "writable", true);
+  }
   return descriptor;
 }
+
+void JavaScriptObject::defineProperty(
+  jsi::Runtime &runtime,
+  jsi::Object *jsthis,
+  const std::string &name,
+  jsi::Object descriptor
+) {
+  jsi::Object global = runtime.global();
+  jsi::Object objectClass = global.getPropertyAsObject(runtime, "Object");
+  jsi::Function definePropertyFunction = objectClass.getPropertyAsFunction(
+    runtime,
+    "defineProperty"
+  );
+
+  // This call is basically the same as `Object.defineProperty(object, name, descriptor)` in JS
+  definePropertyFunction.callWithThis(runtime, objectClass, {
+    jsi::Value(runtime, *jsthis),
+    jsi::String::createFromUtf8(runtime, name),
+    std::move(descriptor),
+  });
+}
+
+void JavaScriptObject::defineNativeDeallocator(
+  jni::alias_ref<JNIFunctionBody::javaobject> deallocator
+) {
+  auto &rt = runtimeHolder.getJSRuntime();
+  jni::global_ref<JNIFunctionBody::javaobject> globalRef = jni::make_global(deallocator);
+  std::shared_ptr<ObjectDeallocator> nativeDeallocator = std::make_shared<ObjectDeallocator>(
+    [globalRef = std::move(globalRef)]() mutable {
+      auto args = jni::Environment::current()->NewObjectArray(
+        0,
+        JavaReferencesCache::instance()->getJClass("java/lang/Object").clazz,
+        nullptr
+      );
+      globalRef->invoke(args);
+      globalRef.reset();
+    });
+  auto descriptor = JavaScriptObject::preparePropertyDescriptor(rt, 0);
+  descriptor.setProperty(rt, "value", jsi::Object::createFromHostObject(rt, nativeDeallocator));
+  jsObject->setProperty(rt, "__expo_shared_object_deallocator__", std::move(descriptor));
+}
 } // namespace expo