expo-modules-core 1.11.13 → 1.12.1

package/android/src/main/cpp/JSIContext.cpp

@@ -0,0 +1,354 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JSIContext.h"
+#include "ExpoModulesHostObject.h"
+#include "JavaReferencesCache.h"
+#include "JSReferencesCache.h"
+#include "SharedObject.h"
+#include "NativeModule.h"
+
+#include <fbjni/detail/Meta.h>
+#include <fbjni/fbjni.h>
+
+#include <memory>
+
+#if IS_NEW_ARCHITECTURE_ENABLED
+
+#include "BridgelessJSCallInvoker.h"
+
+#endif
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+#if IS_NEW_ARCHITECTURE_ENABLED
+
+#include "BridgelessJSCallInvoker.h"
+
+#endif
+
+jni::local_ref<JSIContext::jhybriddata>
+JSIContext::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void JSIContext::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("initHybrid", JSIContext::initHybrid),
+                   makeNativeMethod("installJSI", JSIContext::installJSI),
+#if IS_NEW_ARCHITECTURE_ENABLED
+                   makeNativeMethod("installJSIForBridgeless",
+                                    JSIContext::installJSIForBridgeless),
+#endif
+                   makeNativeMethod("installJSIForTests",
+                                    JSIContext::installJSIForTests),
+                   makeNativeMethod("evaluateScript", JSIContext::evaluateScript),
+                   makeNativeMethod("global", JSIContext::global),
+                   makeNativeMethod("createObject", JSIContext::createObject),
+                   makeNativeMethod("drainJSEventLoop", JSIContext::drainJSEventLoop),
+                   makeNativeMethod("setNativeStateForSharedObject",
+                                    JSIContext::jniSetNativeStateForSharedObject),
+                 });
+}
+
+JSIContext::JSIContext(jni::alias_ref<jhybridobject> jThis)
+  : javaPart_(jni::make_global(jThis)) {}
+
+JSIContext::~JSIContext() {
+  unbindJSIContext(runtimeHolder->get());
+  // The runtime would be deallocated automatically.
+  // However, we need to enforce the order of deallocations.
+  // The runtime has to be deallocated before the JNI part.
+  runtimeHolder.reset();
+}
+
+void JSIContext::installJSI(
+  jlong jsRuntimePointer,
+  jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator,
+  jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder
+) {
+  prepareJSIContext(
+    jsRuntimePointer,
+    jniDeallocator,
+    jsInvokerHolder->cthis()->getCallInvoker()
+  );
+
+  prepareRuntime();
+}
+
+#if IS_NEW_ARCHITECTURE_ENABLED
+
+void JSIContext::installJSIForBridgeless(
+  jlong jsRuntimePointer,
+  jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator,
+  jni::alias_ref<react::JRuntimeExecutor::javaobject> runtimeExecutor
+) {
+  prepareJSIContext(
+    jsRuntimePointer,
+    jniDeallocator,
+    std::make_shared<BridgelessJSCallInvoker>(runtimeExecutor->cthis()->get())
+  );
+
+  prepareRuntime();
+}
+
+#endif
+
+void JSIContext::installJSIForTests(
+  jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator
+) {
+#if !UNIT_TEST
+  throw std::logic_error("The function is only available when UNIT_TEST is defined.");
+#else
+  this->jniDeallocator = jni::make_global(jniDeallocator);
+
+  runtimeHolder = std::make_shared<JavaScriptRuntime>();
+  jsi::Runtime &jsiRuntime = runtimeHolder->get();
+
+  jsRegistry = std::make_unique<JSReferencesCache>(jsiRuntime);
+
+  prepareRuntime();
+#endif // !UNIT_TEST
+}
+
+void JSIContext::prepareJSIContext(
+  jlong jsRuntimePointer,
+  jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator,
+  std::shared_ptr<react::CallInvoker> callInvoker
+) {
+  this->jniDeallocator = jni::make_global(jniDeallocator);
+  auto runtime = reinterpret_cast<jsi::Runtime *>(jsRuntimePointer);
+  jsRegistry = std::make_unique<JSReferencesCache>(*runtime);
+
+  runtimeHolder = std::make_shared<JavaScriptRuntime>(
+    runtime,
+    std::move(callInvoker)
+  );
+}
+
+void JSIContext::prepareRuntime() {
+  jsi::Runtime &runtime = runtimeHolder->get();
+
+  bindJSIContext(runtime, this);
+
+  runtimeHolder->installMainObject();
+
+  EventEmitter::installClass(runtime);
+
+  SharedObject::installBaseClass(
+    runtime,
+    // We can't predict the order of deallocation of the JSIContext and the SharedObject.
+    // So we need to pass a new ref to retain the JSIContext to make sure it's not deallocated before the SharedObject.
+    [javaObject = javaPart_](const SharedObject::ObjectId objectId) {
+      jni::ThreadScope::WithClassLoader([objectId = objectId, javaObject = std::move(javaObject)] {
+        JSIContext::deleteSharedObject(javaObject, objectId);
+      });
+    }
+  );
+
+  NativeModule::installClass(runtime);
+
+  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
+  auto expoModulesObject = jsi::Object::createFromHostObject(
+    runtime,
+    expoModules
+  );
+
+  // Define the `global.expo.modules` object.
+  runtimeHolder
+    ->getMainObject()
+    ->setProperty(
+      runtime,
+      "modules",
+      expoModulesObject
+    );
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIContext::callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("getJavaScriptModuleObject: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<jni::local_ref<JavaScriptModuleObject::javaobject>(
+      std::string)>(
+      "getJavaScriptModuleObject"
+    );
+
+  return method(javaPart_, moduleName);
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIContext::callGetCoreModuleObject() const {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("getCoreModule: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<jni::local_ref<JavaScriptModuleObject::javaobject>()>(
+      "getCoreModuleObject"
+    );
+  return method(javaPart_);
+}
+
+jni::local_ref<jni::JArrayClass<jni::JString>>
+JSIContext::callGetJavaScriptModulesNames() const {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("getJavaScriptModules: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>(
+      "getJavaScriptModulesName"
+    );
+  return method(javaPart_);
+}
+
+bool JSIContext::callHasModule(const std::string &moduleName) const {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("hasModule: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<jboolean(std::string)>(
+      "hasModule"
+    );
+  return (bool) method(javaPart_, moduleName);
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIContext::getModule(const std::string &moduleName) const {
+  return callGetJavaScriptModuleObjectMethod(moduleName);
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject> JSIContext::getCoreModule() const {
+  return callGetCoreModuleObject();
+}
+
+bool JSIContext::hasModule(const std::string &moduleName) const {
+  return callHasModule(moduleName);
+}
+
+jni::local_ref<jni::JArrayClass<jni::JString>> JSIContext::getModulesName() const {
+  return callGetJavaScriptModulesNames();
+}
+
+jni::local_ref<JavaScriptValue::javaobject> JSIContext::evaluateScript(
+  jni::JString script
+) {
+  return runtimeHolder->evaluateScript(script.toStdString());
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIContext::global() {
+  return runtimeHolder->global();
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIContext::createObject() {
+  return runtimeHolder->createObject();
+}
+
+void JSIContext::drainJSEventLoop() {
+  runtimeHolder->drainJSEventLoop();
+}
+
+void JSIContext::registerSharedObject(
+  jni::local_ref<jobject> native,
+  jni::local_ref<JavaScriptObject::javaobject> js
+) {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("registerSharedObject: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<void(jni::local_ref<jobject>, jni::local_ref<JavaScriptObject::javaobject>)>(
+      "registerSharedObject"
+    );
+  method(javaPart_, std::move(native), std::move(js));
+}
+
+void JSIContext::deleteSharedObject(
+  jni::global_ref<JSIContext::javaobject> javaObject,
+  int objectId
+) {
+  if (javaObject == nullptr) {
+    throw std::runtime_error("deleteSharedObject: JSIContext is invalid.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<void(int)>(
+      "deleteSharedObject"
+    );
+  method(javaObject, objectId);
+}
+
+void JSIContext::registerClass(
+  jni::local_ref<jclass> native,
+  jni::local_ref<JavaScriptObject::javaobject> jsClass
+) {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("registerClass: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<void(jni::local_ref<jclass>, jni::local_ref<JavaScriptObject::javaobject>)>(
+      "registerClass"
+    );
+  method(javaPart_, std::move(native), std::move(jsClass));
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIContext::getJavascriptClass(
+  jni::local_ref<jclass> native
+) {
+  if (javaPart_ == nullptr) {
+    throw std::runtime_error("getJavascriptClass: JSIContext was prepared to be deallocated.");
+  }
+
+  const static auto method = expo::JSIContext::javaClassLocal()
+    ->getMethod<jni::local_ref<JavaScriptObject::javaobject>(jni::local_ref<jclass>)>(
+      "getJavascriptClass"
+    );
+  return method(javaPart_, std::move(native));
+}
+
+void JSIContext::prepareForDeallocation() {
+  jsRegistry.reset();
+  runtimeHolder.reset();
+  jniDeallocator.reset();
+  javaPart_.reset();
+}
+
+void JSIContext::jniSetNativeStateForSharedObject(
+  int id,
+  jni::alias_ref<JavaScriptObject::javaobject> jsObject
+) {
+  auto nativeState = std::make_shared<expo::SharedObject::NativeState>(
+    id,
+    // We can't predict the order of deallocation of the JSIContext and the SharedObject.
+    // So we need to pass a new ref to retain the JSIContext to make sure it's not deallocated before the SharedObject.
+    [javaObject = javaPart_](const SharedObject::ObjectId objectId) {
+      jni::ThreadScope::WithClassLoader([objectId = objectId, javaObject = std::move(javaObject)] {
+        JSIContext::deleteSharedObject(javaObject, objectId);
+      });
+    }
+  );
+
+  jsObject
+    ->cthis()
+    ->get()
+    ->setNativeState(runtimeHolder->get(), std::move(nativeState));
+}
+
+thread_local std::unordered_map<uintptr_t, JSIContext *> jsiContexts;
+
+void bindJSIContext(const jsi::Runtime &runtime, JSIContext *jsiContext) {
+  jsiContexts[reinterpret_cast<uintptr_t>(&runtime)] = jsiContext;
+}
+
+void unbindJSIContext(const jsi::Runtime &runtime) {
+  jsiContexts.erase(reinterpret_cast<uintptr_t>(&runtime));
+}
+
+} // namespace expo

package/android/src/main/cpp/{JSIInteropModuleRegistry.h → JSIContext.h}

@@ -14,8 +14,18 @@
 #include <jsi/jsi.h>
 #include <ReactCommon/CallInvokerHolder.h>
 #include <ReactCommon/CallInvoker.h>
+
+#if IS_NEW_ARCHITECTURE_ENABLED
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <react/jni/JRuntimeExecutor.h>
+
+#endif
+
 #if REACT_NATIVE_TARGET_VERSION >= 73
+
 #include <ReactCommon/NativeMethodCallInvokerHolder.h>
+
 #endif
 
 #include <memory>
@@ -29,11 +39,10 @@ namespace expo {
 /**
  * A JNI wrapper to initialize CPP part of modules and access all data from the module registry.
  */
-class JSIInteropModuleRegistry : public jni::HybridClass<JSIInteropModuleRegistry> {
+class JSIContext : public jni::HybridClass<JSIContext> {
 public:
-  static auto constexpr
-    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JSIInteropModuleRegistry;";
-  static auto constexpr TAG = "JSIInteropModuleRegistry";
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/jni/JSIContext;";
+  static auto constexpr TAG = "JSIContext";
 
   static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
 
@@ -48,6 +57,19 @@ public:
     jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder
   );
 
+#if IS_NEW_ARCHITECTURE_ENABLED
+
+  /**
+     * Initializes the `ExpoModulesHostObject` and adds it to the global object.
+     */
+    void installJSIForBridgeless(
+      jlong jsRuntimePointer,
+      jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator,
+      jni::alias_ref<react::JRuntimeExecutor::javaobject> runtimeExecutor
+    );
+
+#endif
+
   /**
    * Initializes the test runtime. Shouldn't be used in the production.
    */
@@ -100,22 +122,34 @@ public:
     jni::local_ref<JavaScriptObject::javaobject> js
   );
 
+  static void deleteSharedObject(
+    jni::global_ref<JSIContext::javaobject> javaObject,
+    int objectId
+  );
+
   /**
    * Exposes a `JavaScriptRuntime::drainJSEventLoop` function to Kotlin
    */
   void drainJSEventLoop();
 
-  std::shared_ptr<react::CallInvoker> jsInvoker;
   std::shared_ptr<JavaScriptRuntime> runtimeHolder;
   std::unique_ptr<JSReferencesCache> jsRegistry;
   jni::global_ref<JNIDeallocator::javaobject> jniDeallocator;
 
-  bool wasDeallocated = false;
+  void registerClass(jni::local_ref<jclass> native,
+                     jni::local_ref<JavaScriptObject::javaobject> jsClass);
+
+  jni::local_ref<JavaScriptObject::javaobject> getJavascriptClass(jni::local_ref<jclass> native);
+
+  ~JSIContext();
+
+  void prepareForDeallocation();
+
 private:
   friend HybridBase;
-  jni::global_ref<JSIInteropModuleRegistry::javaobject> javaPart_;
+  jni::global_ref<JSIContext::javaobject> javaPart_;
 
-  explicit JSIInteropModuleRegistry(jni::alias_ref<jhybridobject> jThis);
+  explicit JSIContext(jni::alias_ref<jhybridobject> jThis);
 
   inline jni::local_ref<JavaScriptModuleObject::javaobject>
   callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const;
@@ -126,6 +160,53 @@ private:
 
   inline bool callHasModule(const std::string &moduleName) const;
 
-  void jniWasDeallocated();
+  void prepareJSIContext(
+    jlong jsRuntimePointer,
+    jni::alias_ref<JNIDeallocator::javaobject> jniDeallocator,
+    std::shared_ptr<react::CallInvoker> callInvoker
+  );
+
+  void prepareRuntime();
+
+  void jniSetNativeStateForSharedObject(
+    int id,
+    jni::alias_ref<JavaScriptObject::javaobject> jsObject
+  );
 };
+
+/**
+ * We are binding the JSIContext to the runtime using a thread-local map.
+ * This is a simplification of how we're accessing the JSIContext from different places.
+ * We're using a thread-local map to prevent from accessing the wrong JSIContext from a different thread.
+ * It's much safer than passing around the JSIContext as a parameter.
+ */
+extern thread_local std::unordered_map<uintptr_t, JSIContext *> jsiContexts;
+
+/**
+ * Binds the JSIContext to the runtime.
+ * @param runtime
+ * @param jsiContext
+ */
+void bindJSIContext(const jsi::Runtime &runtime, JSIContext *jsiContext);
+
+/**
+ * Unbinds the JSIContext from the runtime.
+ * @param runtime
+ */
+void unbindJSIContext(const jsi::Runtime &runtime);
+
+/**
+ * Gets the JSIContext for the given runtime.
+ * @param runtime
+ * @return JSIContext * - it should never be stored when received from this function.
+ * It might throw an exception if the JSIContext for the given runtime doesn't exist.
+ */
+inline JSIContext *getJSIContext(const jsi::Runtime &runtime) {
+  const auto iterator = jsiContexts.find(reinterpret_cast<uintptr_t>(&runtime));
+  if (iterator == jsiContexts.end()) {
+    throw std::invalid_argument("JSIContext for the given runtime doesn't exist");
+  }
+  return iterator->second;
+}
+
 } // namespace expo