expo-modules-core 1.11.13 → 1.12.1

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

@@ -1,10 +1,14 @@
 // Copyright © 2021-present 650 Industries, Inc. (aka Expo)
 
 #include "JavaScriptModuleObject.h"
-#include "JSIInteropModuleRegistry.h"
+#include "JSIContext.h"
 #include "JSIUtils.h"
+#include "EventEmitter.h"
+#include "SharedObject.h"
+#include "NativeModule.h"
 
 #include <folly/dynamic.h>
+#include <jni.h>
 #include <jsi/JSIDynamic.h>
 #include <react/jni/ReadableNativeArray.h>
 #include <fbjni/detail/Hybrid.h>
@@ -27,21 +31,19 @@ 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))
+      jsi::Value(runtime, *method->toJSFunction(runtime))
     );
   }
 }
 
 void decorateObjectWithProperties(
   jsi::Runtime &runtime,
-  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
   jsi::Object *jsObject,
   JavaScriptModuleObject *objectData) {
   for (auto &[name, property]: objectData->properties) {
@@ -52,22 +54,19 @@ void decorateObjectWithProperties(
     descriptor.setProperty(
       runtime,
       "get",
-      jsi::Value(runtime, *getter.toJSFunction(runtime,
-                                               jsiInteropModuleRegistry))
+      jsi::Value(runtime, *getter->toJSFunction(runtime))
     );
     descriptor.setProperty(
       runtime,
       "set",
-      jsi::Value(runtime, *setter.toJSFunction(runtime,
-                                               jsiInteropModuleRegistry))
+      jsi::Value(runtime, *setter->toJSFunction(runtime))
     );
-    common::definePropertyOnJSIObject(runtime, jsObject, name.c_str(), std::move(descriptor));
+    common::defineProperty(runtime, jsObject, name.c_str(), std::move(descriptor));
   }
 }
 
 void decorateObjectWithConstants(
   jsi::Runtime &runtime,
-  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
   jsi::Object *jsObject,
   JavaScriptModuleObject *objectData) {
   for (const auto &[name, value]: objectData->constants) {
@@ -81,7 +80,7 @@ void decorateObjectWithConstants(
 
 jni::local_ref<jni::HybridClass<JavaScriptModuleObject>::jhybriddata>
 JavaScriptModuleObject::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-  return makeCxxInstance(jThis);
+  return makeCxxInstance();
 }
 
 void JavaScriptModuleObject::registerNatives() {
@@ -97,7 +96,9 @@ void JavaScriptModuleObject::registerNatives() {
                    makeNativeMethod("registerClass",
                                     JavaScriptModuleObject::registerClass),
                    makeNativeMethod("registerViewPrototype",
-                                    JavaScriptModuleObject::registerViewPrototype)
+                                    JavaScriptModuleObject::registerViewPrototype),
+                   makeNativeMethod("emitEvent",
+                                    JavaScriptModuleObject::emitEvent)
                  });
 }
 
@@ -106,30 +107,33 @@ std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &
     return object;
   }
 
-  auto moduleObject = std::make_shared<jsi::Object>(runtime);
+  auto moduleObject = std::make_shared<jsi::Object>(NativeModule::createInstance(runtime));
 
+  decorate(runtime, moduleObject.get());
+
+  jsiObject = moduleObject;
+  return moduleObject;
+}
+
+void JavaScriptModuleObject::decorate(jsi::Runtime &runtime, jsi::Object *moduleObject) {
   decorateObjectWithConstants(
     runtime,
-    jsiInteropModuleRegistry,
-    moduleObject.get(),
+    moduleObject,
     this
   );
   decorateObjectWithProperties(
     runtime,
-    jsiInteropModuleRegistry,
-    moduleObject.get(),
+    moduleObject,
     this
   );
   decorateObjectWithFunctions(
     runtime,
-    jsiInteropModuleRegistry,
-    moduleObject.get(),
+    moduleObject,
     this
   );
 
   if (viewPrototype) {
     auto viewPrototypeObject = viewPrototype->cthis();
-    viewPrototypeObject->jsiInteropModuleRegistry = jsiInteropModuleRegistry;
     auto viewPrototypeJSIObject = viewPrototypeObject->getJSIObject(runtime);
     moduleObject->setProperty(
       runtime,
@@ -139,39 +143,27 @@ std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &
   }
 
   for (auto &[name, classInfo]: classes) {
-    auto &[classRef, constructor] = classInfo;
+    auto &[classRef, constructor, ownerClass] = 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(
+    auto weakConstructor = std::weak_ptr(constructor);
+    auto klass = SharedObject::createClass(
       runtime,
-      nativeConstructorPropId,
-      // The paramCount is not obligatory to match, it only affects the `length` property of the function.
-      0,
-      [classObject, &constructor = constructor, jsiInteropModuleRegistry = jsiInteropModuleRegistry](
+      name.c_str(),
+      [classObject, weakConstructor = std::move(weakConstructor)](
         jsi::Runtime &runtime,
         const jsi::Value &thisValue,
         const jsi::Value *args,
         size_t count
       ) -> jsi::Value {
+        // We need to check if the constructor is still alive.
+        // If not we can just ignore the call. We're destroying the module.
+        auto ctr = weakConstructor.lock();
+        if (ctr == nullptr) {
+          return jsi::Value::undefined();
+        }
+
         auto thisObject = std::make_shared<jsi::Object>(thisValue.asObject(runtime));
-        decorateObjectWithProperties(runtime, jsiInteropModuleRegistry, thisObject.get(),
+        decorateObjectWithProperties(runtime, thisObject.get(),
                                      classObject);
         try {
           JNIEnv *env = jni::Environment::current();
@@ -181,16 +173,15 @@ std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &
           * all LocalReferences are deleted.
           */
           jni::JniLocalScope scope(env, (int) count);
-          auto result = constructor.callJNISync(
+          auto result = ctr->callJNISync(
             env,
             runtime,
-            jsiInteropModuleRegistry,
             thisValue,
             args,
             count
           );
           if (result == nullptr) {
-            return jsi::Value::undefined();
+            return jsi::Value(runtime, thisValue);
           }
           jobject unpackedResult = result.get();
           jclass resultClass = env->GetObjectClass(unpackedResult);
@@ -199,41 +190,52 @@ std::shared_ptr<jsi::Object> JavaScriptModuleObject::getJSIObject(jsi::Runtime &
             JavaReferencesCache::instance()->getJClass(
               "expo/modules/kotlin/sharedobjects/SharedObject").clazz
           )) {
+            JSIContext *jsiContext = getJSIContext(runtime);
             auto jsThisObject = JavaScriptObject::newInstance(
-              jsiInteropModuleRegistry,
-              jsiInteropModuleRegistry->runtimeHolder,
+              jsiContext,
+              jsiContext->runtimeHolder,
               thisObject
             );
-            jsiInteropModuleRegistry->registerSharedObject(result, jsThisObject);
+            jsiContext->registerSharedObject(result, jsThisObject);
           }
+          return jsi::Value(runtime, thisValue);
         } 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));
+    auto klassSharedPtr = std::make_shared<jsi::Function>(std::move(klass));
 
-    common::definePropertyOnJSIObject(runtime, &prototype, nativeConstructorKey.c_str(),
-                                      std::move(descriptor));
+    JSIContext *jsiContext = getJSIContext(runtime);
+
+    auto jsThisObject = JavaScriptObject::newInstance(
+      jsiContext,
+      jsiContext->runtimeHolder,
+      klassSharedPtr
+    );
+
+    if (ownerClass != nullptr) {
+      jsiContext->registerClass(jni::make_local(ownerClass), jsThisObject);
+    }
 
     moduleObject->setProperty(
       runtime,
       jsi::String::createFromUtf8(runtime, name),
-      jsi::Value(runtime, klass.asFunction(runtime))
+      jsi::Value(runtime, *klassSharedPtr.get())
     );
 
+    jsi::PropNameID prototypePropNameId = jsi::PropNameID::forAscii(runtime, "prototype", 9);
+    jsi::Object klassPrototype = klassSharedPtr
+      ->getProperty(runtime, prototypePropNameId)
+      .asObject(runtime);
+
     decorateObjectWithFunctions(
       runtime,
-      jsiInteropModuleRegistry,
-      &prototype,
+      &klassPrototype,
       classObject
     );
   }
-
-  jsiObject = moduleObject;
-  return moduleObject;
 }
 
 void JavaScriptModuleObject::exportConstants(
@@ -254,15 +256,14 @@ void JavaScriptModuleObject::registerSyncFunction(
   jni::alias_ref<JNIFunctionBody::javaobject> body
 ) {
   std::string cName = name->toStdString();
-
-  methodsMetadata.try_emplace(
+  auto methodMetadata = std::make_shared<MethodMetadata>(
     cName,
-    cName,
-    takesOwner,
+    takesOwner & 0x1, // We're unsure if takesOwner can be greater than 1, so we're using bitwise AND to ensure it's 0 or 1.
     false,
     jni::make_local(expectedArgTypes),
     jni::make_global(body)
   );
+  methodsMetadata.insert_or_assign(cName, std::move(methodMetadata));
 }
 
 void JavaScriptModuleObject::registerAsyncFunction(
@@ -272,38 +273,42 @@ void JavaScriptModuleObject::registerAsyncFunction(
   jni::alias_ref<JNIAsyncFunctionBody::javaobject> body
 ) {
   std::string cName = name->toStdString();
-
-  methodsMetadata.try_emplace(
+  auto methodMetadata = std::make_shared<MethodMetadata>(
     cName,
-    cName,
-    takesOwner,
+    takesOwner & 0x1, // We're unsure if takesOwner can be greater than 1, so we're using bitwise AND to ensure it's 0 or 1.
     true,
     jni::make_local(expectedArgTypes),
     jni::make_global(body)
   );
+  methodsMetadata.insert_or_assign(cName, std::move(methodMetadata));
 }
 
 void JavaScriptModuleObject::registerClass(
   jni::alias_ref<jstring> name,
   jni::alias_ref<JavaScriptModuleObject::javaobject> classObject,
   jboolean takesOwner,
+  jni::alias_ref<jclass> ownerClass,
   jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
   jni::alias_ref<JNIFunctionBody::javaobject> body
 ) {
   std::string cName = name->toStdString();
-  MethodMetadata constructor(
+  auto constructor = std::make_shared<MethodMetadata>(
     "constructor",
-    takesOwner,
+    takesOwner & 0x1, // We're unsure if takesOwner can be greater than 1, so we're using bitwise AND to ensure it's 0 or 1.
     false,
     jni::make_local(expectedArgTypes),
     jni::make_global(body)
   );
 
-  auto pair = std::make_pair(jni::make_global(classObject), std::move(constructor));
+  auto classTuple = std::make_tuple(
+    jni::make_global(classObject),
+    std::move(constructor),
+    jni::make_global(ownerClass)
+  );
 
   classes.try_emplace(
     cName,
-    std::move(pair)
+    std::move(classTuple)
   );
 }
 
@@ -324,17 +329,17 @@ void JavaScriptModuleObject::registerProperty(
 ) {
   auto cName = name->toStdString();
 
-  auto getterMetadata = MethodMetadata(
+  auto getterMetadata = make_shared<MethodMetadata>(
     cName,
-    getterTakesOwner,
+    getterTakesOwner & 0x1, // We're unsure if getterTakesOwner can be greater than 1, so we're using bitwise AND to ensure it's 0 or 1.
     false,
     jni::make_local(getterExpectedArgsTypes),
     jni::make_global(getter)
   );
 
-  auto setterMetadata = MethodMetadata(
+  auto setterMetadata = make_shared<MethodMetadata>(
     cName,
-    setterTakesOwner,
+    setterTakesOwner & 0x1, // We're unsure if setterTakesOwner can be greater than 1, so we're using bitwise AND to ensure it's 0 or 1.
     false,
     jni::make_local(setterExpectedArgsTypes),
     jni::make_global(setter)
@@ -345,10 +350,41 @@ void JavaScriptModuleObject::registerProperty(
     std::move(setterMetadata)
   );
 
-  properties.insert({cName, std::move(functions)});
+  properties.insert_or_assign(cName, std::move(functions));
 }
 
-JavaScriptModuleObject::JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis)
-  : javaPart_(jni::make_global(jThis)) {
+void JavaScriptModuleObject::emitEvent(
+  jni::alias_ref<jni::HybridClass<JSIContext>::javaobject> jsiContextRef,
+  jni::alias_ref<jstring> eventName,
+  jni::alias_ref<react::ReadableNativeMap::javaobject> eventBody
+) {
+  const std::string name = eventName->toStdString();
+  folly::dynamic body;
+  if (eventBody) {
+    body = eventBody->cthis()->consume();
+  }
+
+  const JSIContext *jsiContext = jsiContextRef->cthis();
+
+  jsiContext->runtimeHolder->jsInvoker->invokeAsync([
+    jsiContext,
+    name = std::move(name),
+    body = std::move(body),
+    weakThis = jsiObject
+  ]() {
+    std::shared_ptr<jsi::Object> jsThis = weakThis.lock();
+    if (!jsThis) {
+      return;
+    }
+
+    // TODO(@lukmccall): refactor when jsInvoker recieves a runtime as a parameter
+    jsi::Runtime &rt  = jsiContext->runtimeHolder->get();
+
+    jsi::Value convertedBody = jsi::valueFromDynamic(rt, body);
+    std::vector<jsi::Value> args;
+    args.emplace_back(std::move(convertedBody));
+
+    EventEmitter::emitEvent(rt, *jsThis, name, args);
+  });
 }
 } // namespace expo

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

@@ -5,6 +5,7 @@
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
 #include <react/jni/ReadableNativeArray.h>
+#include <react/jni/ReadableNativeMap.h>
 #include <jni/JCallback.h>
 
 #include <unordered_map>
@@ -18,27 +19,24 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
 namespace expo {
-class JSIInteropModuleRegistry;
+class JSIContext;
 
 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
 );
@@ -59,11 +57,6 @@ public:
 
   static void registerNatives();
 
-  /**
-   * Pointer to the module registry interop.
-   */
-  JSIInteropModuleRegistry *jsiInteropModuleRegistry;
-
   /**
    * Returns a cached instance of jsi::Object representing this module.
    * @param runtime
@@ -71,6 +64,11 @@ public:
    */
   std::shared_ptr<jsi::Object> getJSIObject(jsi::Runtime &runtime);
 
+  /**
+   * Decorates the given object with properties and functions provided in the module definition.
+   */
+  void decorate(jsi::Runtime &runtime, jsi::Object *moduleObject);
+
   /**
    * Exports constants that will be assigned to the underlying HostObject.
    */
@@ -102,6 +100,7 @@ public:
     jni::alias_ref<jstring> name,
     jni::alias_ref<JavaScriptModuleObject::javaobject> classObject,
     jboolean takesOwner,
+    jni::alias_ref<jclass> ownerClass,
     jni::alias_ref<jni::JArrayClass<ExpectedType>> expectedArgTypes,
     jni::alias_ref<JNIFunctionBody::javaobject> body
   );
@@ -127,29 +126,34 @@ public:
     jni::alias_ref<JNIFunctionBody::javaobject> setter
   );
 
-private:
-  explicit JavaScriptModuleObject(jni::alias_ref<jhybridobject> jThis);
+  /**
+   * Emits an event using cached jsi::Object with the given name and body.
+   * @param eventName
+   * @param eventBody
+   */
+  void emitEvent(
+    jni::alias_ref<jni::HybridClass<JSIContext>::javaobject> jsiContextRef,
+    jni::alias_ref<jstring> eventName,
+    jni::alias_ref<react::ReadableNativeMap::javaobject> eventBody
+  );
 
 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
   );
@@ -161,12 +165,11 @@ private:
    * Doing that allows the runtime to deallocate jsi::Object if it's not needed anymore.
    */
   std::weak_ptr<jsi::Object> jsiObject;
-  jni::global_ref<JavaScriptModuleObject::javaobject> javaPart_;
 
   /**
    * Metadata map that stores information about all available methods on this module.
    */
-  std::unordered_map<std::string, MethodMetadata> methodsMetadata;
+  std::unordered_map<std::string, std::shared_ptr<MethodMetadata>> methodsMetadata;
 
   /**
    * A constants map.
@@ -177,11 +180,11 @@ private:
    * 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;
+  std::map<std::string, std::pair<std::shared_ptr<MethodMetadata>, std::shared_ptr<MethodMetadata>>> properties;
 
   std::map<
     std::string,
-    std::pair<jni::global_ref<JavaScriptModuleObject::javaobject>, MethodMetadata>
+    std::tuple<jni::global_ref<JavaScriptModuleObject::javaobject>, std::shared_ptr<MethodMetadata>, jni::global_ref<jclass>>
   > classes;
 
   jni::global_ref<JavaScriptModuleObject::javaobject> viewPrototype;

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

@@ -8,7 +8,7 @@
 #include "JSITypeConverter.h"
 #include "ObjectDeallocator.h"
 #include "JavaReferencesCache.h"
-#include "JSIInteropModuleRegistry.h"
+#include "JSIContext.h"
 
 namespace expo {
 void JavaScriptObject::registerNatives() {
@@ -77,7 +77,7 @@ jni::local_ref<JavaScriptValue::javaobject> JavaScriptObject::jniGetProperty(
 ) {
   auto result = std::make_shared<jsi::Value>(getProperty(name->toStdString()));
   return JavaScriptValue::newInstance(
-    runtimeHolder.getModuleRegistry(),
+    runtimeHolder.getJSIContext(),
     runtimeHolder,
     result
   );
@@ -113,7 +113,7 @@ jni::local_ref<jni::JArrayClass<jstring>> JavaScriptObject::jniGetPropertyNames(
 
 jni::local_ref<jni::HybridClass<JavaScriptWeakObject, Destructible>::javaobject> JavaScriptObject::createWeak() {
   return JavaScriptWeakObject::newInstance(
-    runtimeHolder.getModuleRegistry(),
+    runtimeHolder.getJSIContext(),
     runtimeHolder,
     get()
   );
@@ -123,7 +123,7 @@ jni::local_ref<JavaScriptFunction::javaobject> JavaScriptObject::jniAsFunction()
   auto &jsRuntime = runtimeHolder.getJSRuntime();
   auto jsFuncion = std::make_shared<jsi::Function>(jsObject->asFunction(jsRuntime));
   return JavaScriptFunction::newInstance(
-    runtimeHolder.getModuleRegistry(),
+    runtimeHolder.getJSIContext(),
     runtimeHolder,
     jsFuncion
   );
@@ -158,12 +158,12 @@ jsi::Object JavaScriptObject::preparePropertyDescriptor(
 }
 
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptObject::newInstance(
-  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  JSIContext *jsiContext,
   std::weak_ptr<JavaScriptRuntime> runtime,
   std::shared_ptr<jsi::Object> jsObject
 ) {
   auto object = JavaScriptObject::newObjectCxxArgs(std::move(runtime), std::move(jsObject));
-  jsiInteropModuleRegistry->jniDeallocator->addReference(object);
+  jsiContext->jniDeallocator->addReference(object);
   return object;
 }
 
@@ -184,8 +184,7 @@ void JavaScriptObject::defineNativeDeallocator(
       );
       globalRef->invoke(args);
       globalRef.reset();
-    },
-    "__expo_shared_object_deallocator__"
+    }
   );
 }
 } // namespace expo

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

@@ -37,7 +37,7 @@ public:
   static void registerNatives();
 
   static jni::local_ref<JavaScriptObject::javaobject> newInstance(
-    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    JSIContext *jsiContext,
     std::weak_ptr<JavaScriptRuntime> runtime,
     std::shared_ptr<jsi::Object> jsObject
   );
@@ -52,6 +52,8 @@ public:
     std::shared_ptr<jsi::Object> jsObject
   );
 
+  virtual ~JavaScriptObject() = default;
+
   std::shared_ptr<jsi::Object> get() override;
 
   /**
@@ -137,7 +139,7 @@ private:
     auto cName = name->toStdString();
     jsi::Object descriptor = preparePropertyDescriptor(jsRuntime, options);
     descriptor.setProperty(jsRuntime, "value", jsi_type_converter<T>::convert(jsRuntime, value));
-    common::definePropertyOnJSIObject(jsRuntime, jsObject.get(), cName.c_str(), std::move(descriptor));
+    common::defineProperty(jsRuntime, jsObject.get(), cName.c_str(), std::move(descriptor));
   }
 };
 } // namespace expo