expo-modules-core 0.9.2 → 0.11.1

package/android/src/main/cpp/CachedReferencesRegistry.cpp

@@ -0,0 +1,65 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "CachedReferencesRegistry.h"
+
+#include <utility>
+
+namespace expo {
+std::shared_ptr<CachedReferencesRegistry> CachedReferencesRegistry::instance() {
+  static std::shared_ptr<CachedReferencesRegistry> singleton{new CachedReferencesRegistry};
+  return singleton;
+}
+
+void CachedReferencesRegistry::loadJClasses(JNIEnv *env) {
+  loadJClass(env, "java/lang/Double", {
+    {"<init>", "(D)V"}
+  });
+
+  loadJClass(env, "java/lang/Boolean", {
+    {"<init>", "(Z)V"}
+  });
+
+  loadJClass(env, "com/facebook/react/bridge/PromiseImpl", {
+    {"<init>", "(Lcom/facebook/react/bridge/Callback;Lcom/facebook/react/bridge/Callback;)V"}
+  });
+}
+
+void CachedReferencesRegistry::loadJClass(
+  JNIEnv *env,
+  const std::string &name,
+  const std::vector<std::pair<std::string, std::string>> &methodsNames
+) {
+  // Note this clazz variable points to a leaked global reference.
+  // This is appropriate for classes that are never unloaded which is any class in an Android app.
+  auto clazz = (jclass) env->NewGlobalRef(env->FindClass(name.c_str()));
+
+  MethodHashMap methods;
+  methods.reserve(methodsNames.size());
+
+  for (auto &method: methodsNames) {
+    methods.insert(
+      {method, env->GetMethodID(clazz, method.first.c_str(), method.second.c_str())}
+    );
+  }
+
+  jClassRegistry.insert(
+    {name, CachedJClass(clazz, std::move(methods))}
+  );
+}
+
+CachedReferencesRegistry::CachedJClass &CachedReferencesRegistry::getJClass(
+  const std::string &className
+) {
+  return jClassRegistry.at(className);
+}
+
+jmethodID CachedReferencesRegistry::CachedJClass::getMethod(const std::string &name,
+                                                            const std::string &signature) {
+  return methods.at({name, signature});
+}
+
+CachedReferencesRegistry::CachedJClass::CachedJClass(
+  jclass clazz,
+  MethodHashMap methods
+) : clazz(clazz), methods(std::move(methods)) {}
+} // namespace expo

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

@@ -0,0 +1,80 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <fbjni/fbjni.h>
+#include "boost/functional/hash.hpp"
+
+#include <memory>
+#include <unordered_map>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+using MethodHashMap = std::unordered_map<
+  std::pair<std::string, std::string>,
+  jmethodID,
+  boost::hash<std::pair<std::string, std::string>>
+>;
+
+/**
+ * Singleton registry used to store references to often used Java classes.
+ *
+ * TODO(@lukmccall): also store reference to jsi objects like `Promise`.
+ */
+class CachedReferencesRegistry {
+public:
+  /**
+   * An entry in the Java class registry.
+   */
+  class CachedJClass {
+  public:
+    CachedJClass(jclass clazz, MethodHashMap methods);
+
+    /**
+     * A bare reference to the class object.
+     */
+    jclass clazz;
+
+    /**
+     * Returns a cached method id for provided method name and signature.
+     */
+    jmethodID getMethod(const std::string &name, const std::string &signature);
+
+  private:
+    MethodHashMap methods;
+  };
+
+  CachedReferencesRegistry(CachedReferencesRegistry const &) = delete;
+
+  CachedReferencesRegistry &operator=(CachedReferencesRegistry const &) = delete;
+
+  /**
+   * Gets a singleton instance
+   */
+  static std::shared_ptr<CachedReferencesRegistry> instance();
+
+  /**
+   * Gets a cached Java class entry.
+   */
+  CachedJClass &getJClass(const std::string &className);
+
+  /**
+   * Loads predefined set of Java classes and stores them
+   */
+  void loadJClasses(JNIEnv *env);
+
+private:
+  CachedReferencesRegistry() = default;
+
+  std::unordered_map<std::string, CachedJClass> jClassRegistry;
+
+  void loadJClass(
+    JNIEnv *env,
+    const std::string &name,
+    const std::vector<std::pair<std::string, std::string>> &methods
+  );
+};
+} // namespace expo

package/android/src/main/cpp/Exceptions.cpp

@@ -0,0 +1,22 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "Exceptions.h"
+
+namespace jni = facebook::jni;
+
+namespace expo {
+
+jni::local_ref<CodedException> CodedException::create(const std::string &message) {
+  return CodedException::newInstance(jni::make_jstring(message));
+}
+
+jni::local_ref<JavaScriptEvaluateException> JavaScriptEvaluateException::create(
+  const std::string &message,
+  const std::string &jsStack
+) {
+  return JavaScriptEvaluateException::newInstance(
+    jni::make_jstring(message),
+    jni::make_jstring(jsStack)
+  );
+}
+} // namespace expo

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

@@ -0,0 +1,38 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+
+namespace jni = facebook::jni;
+
+namespace expo {
+/**
+ * A convenient wrapper for the Kotlin CodedException.
+ * It can be used with the `jni::throwNewJavaException` function to throw a cpp exception that
+ * will be automatically changed to the corresponding Java/Kotlin exception.
+ * `jni::throwNewJavaException` creates and throws a C++ exception which wraps a Java exception,
+ * so the C++ flow is interrupted. Then, when translatePendingCppExceptionToJavaException
+ * is called at the topmost level of the native stack, the wrapped Java exception is thrown to the java caller.
+ */
+class CodedException : public jni::JavaClass<CodedException, jni::JThrowable> {
+public:
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/exception/CodedException;";
+
+  static jni::local_ref<CodedException> create(const std::string &message);
+};
+
+/**
+ * A convenient wrapper for the Kotlin JavaScriptEvaluateException.
+ */
+class JavaScriptEvaluateException
+  : public jni::JavaClass<JavaScriptEvaluateException, CodedException> {
+public:
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/exception/JavaScriptEvaluateException;";
+
+  static jni::local_ref<JavaScriptEvaluateException> create(
+    const std::string &message,
+    const std::string &jsStack
+  );
+};
+} // namespace expo

package/android/src/main/cpp/ExpoModulesHostObject.cpp

@@ -0,0 +1,47 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "ExpoModulesHostObject.h"
+
+#include <folly/dynamic.h>
+#include <jsi/JSIDynamic.h>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+ExpoModulesHostObject::ExpoModulesHostObject(JSIInteropModuleRegistry *installer)
+  : installer(installer) {}
+
+jsi::Value ExpoModulesHostObject::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+  auto cName = name.utf8(runtime);
+  auto module = installer->getModule(cName);
+  if (module == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  module->cthis()->jsiInteropModuleRegistry = installer;
+  auto jsiObject = module->cthis()->getJSIObject(runtime);
+  return jsi::Value(runtime, *jsiObject);
+}
+
+void ExpoModulesHostObject::set(jsi::Runtime &runtime, const jsi::PropNameID &name,
+                                const jsi::Value &value) {
+  throw jsi::JSError(
+    runtime,
+    "RuntimeError: Cannot override the host object for expo module '" + name.utf8(runtime) + "'"
+  );
+}
+
+std::vector<jsi::PropNameID> ExpoModulesHostObject::getPropertyNames(jsi::Runtime &rt) {
+  auto names = installer->getModulesName();
+  size_t size = names->size();
+  std::vector<jsi::PropNameID> result;
+  result.reserve(size);
+  for (int i = 0; i < size; i++) {
+    result.push_back(
+      jsi::PropNameID::forUtf8(rt, names->getElement(i)->toStdString())
+    );
+  }
+  return result;
+}
+} // namespace expo

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

@@ -0,0 +1,32 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JSIInteropModuleRegistry.h"
+
+#include <jsi/jsi.h>
+
+#include <vector>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+/**
+ * An entry point to all exported functionalities like modules.
+ *
+ * An instance of this class will be added to the JS global object.
+ */
+class ExpoModulesHostObject : public jsi::HostObject {
+public:
+  ExpoModulesHostObject(JSIInteropModuleRegistry *installer);
+
+  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;
+
+private:
+  JSIInteropModuleRegistry *installer;
+};
+} // namespace expo

package/android/src/main/cpp/JNIFunctionBody.cpp

@@ -0,0 +1,44 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JNIFunctionBody.h"
+
+namespace jni = facebook::jni;
+namespace react = facebook::react;
+
+namespace expo {
+jni::local_ref<react::ReadableNativeArray::javaobject>
+JNIFunctionBody::invoke(jni::local_ref<jni::JArrayClass<jobject>> &&args) {
+  // Do NOT use getClass here!
+  // Method obtained from `getClass` will point to the overridden version of the method.
+  // Because of that, it can't be cached - we will try to invoke the nonexistent method
+  // if we receive an object of a different class than the one used to obtain the method id.
+  // The only cacheable method id can be obtain from the base class.
+  static const auto method = jni::findClassLocal("expo/modules/kotlin/jni/JNIFunctionBody")
+    ->getMethod<
+      react::ReadableNativeArray::javaobject(jni::local_ref<jni::JArrayClass<jobject>>)
+    >(
+      "invoke"
+    );
+
+  return method(this->self(), args);
+}
+
+void JNIAsyncFunctionBody::invoke(
+  jni::local_ref<jni::JArrayClass<jobject>> &&args,
+  jobject promise
+) {
+  // Do NOT use getClass here!
+  // Method obtained from `getClass` will point to the overridden version of the method.
+  // Because of that, it can't be cached - we will try to invoke the nonexistent method
+  // if we receive an object of a different class than the one used to obtain the method id.
+  // The only cacheable method id can be obtain from the base class.
+  static const auto method = jni::findClassLocal("expo/modules/kotlin/jni/JNIAsyncFunctionBody")
+    ->getMethod<
+      void(jni::local_ref<jni::JArrayClass<jobject>>, jobject)
+    >(
+      "invoke"
+    );
+
+  method(this->self(), args, promise);
+}
+} // namespace expo

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

@@ -0,0 +1,50 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/jni/ReadableNativeArray.h>
+
+namespace jni = facebook::jni;
+namespace react = facebook::react;
+
+namespace expo {
+/**
+ * A CPP part of the expo.modules.kotlin.jni.JNIFunctionBody class.
+ * It represents the Kotlin's promise-less function.
+ */
+class JNIFunctionBody : public jni::JavaClass<JNIFunctionBody> {
+public:
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/jni/JNIFunctionBody;";
+
+  /**
+   * Invokes a Kotlin's implementation of this function.
+   *
+   * @param args
+   * @return result of the Kotlin function
+   */
+  jni::local_ref<react::ReadableNativeArray::javaobject> invoke(
+    jni::local_ref<jni::JArrayClass<jobject>> &&args
+  );
+};
+
+/**
+ * A CPP part of the expo.modules.kotlin.jni.JNIAsyncFunctionBody class.
+ * It represents the Kotlin's promise function.
+ */
+class JNIAsyncFunctionBody : public jni::JavaClass<JNIAsyncFunctionBody> {
+public:
+  static auto constexpr kJavaDescriptor = "Lexpo/modules/kotlin/jni/JNIAsyncFunctionBody;";
+
+  /**
+   * Invokes a Kotlin's implementation of this async function.
+   *
+   * @param args
+   * @param promise that will be resolve or rejected in the Kotlin's implementation
+   */
+  void invoke(
+    jni::local_ref<jni::JArrayClass<jobject>> &&args,
+    jobject promise
+  );
+};
+} // namespace expo

package/android/src/main/cpp/JNIInjector.cpp

@@ -0,0 +1,23 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JSIInteropModuleRegistry.h"
+#include "JavaScriptModuleObject.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+#include "CachedReferencesRegistry.h"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+
+// Install all jni bindings
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
+  return facebook::jni::initialize(vm, [] {
+    // Loads references to often use Java classes
+    expo::CachedReferencesRegistry::instance()->loadJClasses(jni::Environment::current());
+
+    expo::JSIInteropModuleRegistry::registerNatives();
+    expo::JavaScriptModuleObject::registerNatives();
+    expo::JavaScriptValue::registerNatives();
+    expo::JavaScriptObject::registerNatives();
+  });
+}

package/android/src/main/cpp/JSIInteropModuleRegistry.cpp

@@ -0,0 +1,122 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JSIInteropModuleRegistry.h"
+#include "ExpoModulesHostObject.h"
+
+#include <fbjni/detail/Meta.h>
+#include <fbjni/fbjni.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+jni::local_ref<JSIInteropModuleRegistry::jhybriddata>
+JSIInteropModuleRegistry::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  return makeCxxInstance(jThis);
+}
+
+void JSIInteropModuleRegistry::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("initHybrid", JSIInteropModuleRegistry::initHybrid),
+                   makeNativeMethod("installJSI", JSIInteropModuleRegistry::installJSI),
+                   makeNativeMethod("installJSIForTests",
+                                    JSIInteropModuleRegistry::installJSIForTests),
+                   makeNativeMethod("evaluateScript", JSIInteropModuleRegistry::evaluateScript),
+                   makeNativeMethod("global", JSIInteropModuleRegistry::global),
+                   makeNativeMethod("createObject", JSIInteropModuleRegistry::createObject),
+                   makeNativeMethod("drainJSEventLoop", JSIInteropModuleRegistry::drainJSEventLoop),
+                 });
+}
+
+JSIInteropModuleRegistry::JSIInteropModuleRegistry(jni::alias_ref<jhybridobject> jThis)
+  : javaPart_(jni::make_global(jThis)) {}
+
+void JSIInteropModuleRegistry::installJSI(
+  jlong jsRuntimePointer,
+  jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder,
+  jni::alias_ref<react::CallInvokerHolder::javaobject> nativeInvokerHolder
+) {
+  auto runtime = reinterpret_cast<jsi::Runtime *>(jsRuntimePointer);
+  runtimeHolder = std::make_shared<JavaScriptRuntime>(
+    runtime,
+    jsInvokerHolder->cthis()->getCallInvoker(),
+    nativeInvokerHolder->cthis()->getCallInvoker()
+  );
+
+  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
+  auto expoModulesObject = jsi::Object::createFromHostObject(*runtime, expoModules);
+
+  runtime
+    ->global()
+    .setProperty(
+      *runtime,
+      "ExpoModules",
+      std::move(expoModulesObject)
+    );
+}
+
+void JSIInteropModuleRegistry::installJSIForTests() {
+  runtimeHolder = std::make_shared<JavaScriptRuntime>();
+  jsi::Runtime &jsiRuntime = *runtimeHolder->get();
+
+  auto expoModules = std::make_shared<ExpoModulesHostObject>(this);
+  auto expoModulesObject = jsi::Object::createFromHostObject(jsiRuntime, expoModules);
+
+  jsiRuntime
+    .global()
+    .setProperty(
+      jsiRuntime,
+      "ExpoModules",
+      std::move(expoModulesObject)
+    );
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIInteropModuleRegistry::callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const {
+  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
+    ->getMethod<jni::local_ref<JavaScriptModuleObject::javaobject>(
+      std::string)>(
+      "getJavaScriptModuleObject"
+    );
+
+  return method(javaPart_, moduleName);
+}
+
+jni::local_ref<jni::JArrayClass<jni::JString>>
+JSIInteropModuleRegistry::callGetJavaScriptModulesNames() const {
+  const static auto method = expo::JSIInteropModuleRegistry::javaClassLocal()
+    ->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>(
+      "getJavaScriptModulesName"
+    );
+  return method(javaPart_);
+}
+
+jni::local_ref<JavaScriptModuleObject::javaobject>
+JSIInteropModuleRegistry::getModule(const std::string &moduleName) const {
+  return callGetJavaScriptModuleObjectMethod(moduleName);
+}
+
+jni::local_ref<jni::JArrayClass<jni::JString>> JSIInteropModuleRegistry::getModulesName() const {
+  return callGetJavaScriptModulesNames();
+}
+
+jni::local_ref<JavaScriptValue::javaobject> JSIInteropModuleRegistry::evaluateScript(
+  jni::JString script
+) {
+  return runtimeHolder->evaluateScript(script.toStdString());
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIInteropModuleRegistry::global() {
+  return runtimeHolder->global();
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JSIInteropModuleRegistry::createObject() {
+  return runtimeHolder->createObject();
+}
+
+void JSIInteropModuleRegistry::drainJSEventLoop() {
+  runtimeHolder->drainJSEventLoop();
+}
+} // namespace expo

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

@@ -0,0 +1,96 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JavaScriptRuntime.h"
+#include "JavaScriptModuleObject.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+#include <ReactCommon/CallInvokerHolder.h>
+#include <ReactCommon/CallInvoker.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+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> {
+public:
+  static auto constexpr
+    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JSIInteropModuleRegistry;";
+  static auto constexpr TAG = "JSIInteropModuleRegistry";
+
+  static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+
+  static void registerNatives();
+
+  /**
+   * Initializes the `ExpoModulesHostObject` and adds it to the global object.
+   */
+  void installJSI(
+    jlong jsRuntimePointer,
+    jni::alias_ref<react::CallInvokerHolder::javaobject> jsInvokerHolder,
+    jni::alias_ref<react::CallInvokerHolder::javaobject> nativeInvokerHolder
+  );
+
+  /**
+   * Initializes the test runtime. Shouldn't be used in the production.
+   */
+  void installJSIForTests();
+
+  /**
+   * Gets a module for a given name. It will throw an exception if the module doesn't exist.
+   *
+   * @param moduleName
+   * @return An instance of `JavaScriptModuleObject`
+   */
+  jni::local_ref<JavaScriptModuleObject::javaobject> getModule(const std::string &moduleName) const;
+
+  /**
+   * Gets names of all available modules.
+   */
+  jni::local_ref<jni::JArrayClass<jni::JString>> getModulesName() const;
+
+  /**
+   * Exposes a `JavaScriptRuntime::evaluateScript` function to Kotlin
+   */
+  jni::local_ref<JavaScriptValue::javaobject> evaluateScript(jni::JString script);
+
+  /**
+   * Exposes a `JavaScriptRuntime::global` function to Kotlin
+   */
+  jni::local_ref<JavaScriptObject::javaobject> global();
+
+  /**
+   * Exposes a `JavaScriptRuntime::createObject` function to Kotlin
+   */
+  jni::local_ref<JavaScriptObject::javaobject> createObject();
+
+  /**
+   * Exposes a `JavaScriptRuntime::drainJSEventLoop` function to Kotlin
+   */
+  void drainJSEventLoop();
+
+  std::shared_ptr<react::CallInvoker> jsInvoker;
+  std::shared_ptr<react::CallInvoker> nativeInvoker;
+  std::shared_ptr<JavaScriptRuntime> runtimeHolder;
+private:
+  friend HybridBase;
+  jni::global_ref<JSIInteropModuleRegistry::javaobject> javaPart_;
+
+  explicit JSIInteropModuleRegistry(jni::alias_ref<jhybridobject> jThis);
+
+  inline jni::local_ref<JavaScriptModuleObject::javaobject>
+  callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const;
+
+  inline jni::local_ref<jni::JArrayClass<jni::JString>> callGetJavaScriptModulesNames() const;
+};
+} // namespace expo

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

@@ -0,0 +1,33 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+/**
+ * An interface for classes which wrap jsi::Object.
+ */
+class JSIObjectWrapper {
+public:
+  /**
+   * @return a pointer to the underlying jsi::Object.
+   */
+  virtual std::shared_ptr<jsi::Object> get() = 0;
+};
+
+/**
+ * An interface for classes which wrap jsi::Value.
+ */
+class JSIValueWrapper {
+public:
+  /**
+   * @return a pointer to the underlying jsi::Value.
+   */
+  virtual std::shared_ptr<jsi::Value> get() = 0;
+};
+} // namespace expo