expo-modules-core 0.9.0 → 0.10.0

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

@@ -0,0 +1,125 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JavaScriptObject.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptRuntime.h"
+#include "JSITypeConverter.h"
+
+namespace expo {
+void JavaScriptObject::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("hasProperty", JavaScriptObject::jniHasProperty),
+                   makeNativeMethod("getProperty", JavaScriptObject::jniGetProperty),
+                   makeNativeMethod("getPropertyNames", JavaScriptObject::jniGetPropertyNames),
+                   makeNativeMethod("setBoolProperty", JavaScriptObject::setProperty<bool>),
+                   makeNativeMethod("setDoubleProperty", JavaScriptObject::setProperty<double>),
+                   makeNativeMethod("setStringProperty",
+                                    JavaScriptObject::setProperty<jni::alias_ref<jstring>>),
+                   makeNativeMethod("setJSValueProperty",
+                                    JavaScriptObject::setProperty<jni::alias_ref<JavaScriptValue::javaobject>>),
+                   makeNativeMethod("setJSObjectProperty",
+                                    JavaScriptObject::setProperty<jni::alias_ref<JavaScriptObject::javaobject>>),
+                   makeNativeMethod("unsetProperty", JavaScriptObject::unsetProperty),
+                   makeNativeMethod("defineBoolProperty", JavaScriptObject::defineProperty<bool>),
+                   makeNativeMethod("defineDoubleProperty",
+                                    JavaScriptObject::defineProperty<double>),
+                   makeNativeMethod("defineStringProperty",
+                                    JavaScriptObject::defineProperty<jni::alias_ref<jstring>>),
+                   makeNativeMethod("defineJSValueProperty",
+                                    JavaScriptObject::defineProperty<jni::alias_ref<JavaScriptValue::javaobject>>),
+                   makeNativeMethod("defineJSObjectProperty",
+                                    JavaScriptObject::defineProperty<jni::alias_ref<JavaScriptObject::javaobject>>),
+                 });
+}
+
+JavaScriptObject::JavaScriptObject(
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Object> jsObject
+) : runtimeHolder(std::move(runtime)), jsObject(std::move(jsObject)) {
+  assert(runtimeHolder.lock() != nullptr);
+}
+
+std::shared_ptr<jsi::Object> JavaScriptObject::get() {
+  return jsObject;
+}
+
+bool JavaScriptObject::hasProperty(const std::string &name) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  return jsObject->hasProperty(*runtime->get(), name.c_str());
+}
+
+jsi::Value JavaScriptObject::getProperty(const std::string &name) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  return jsObject->getProperty(*runtime->get(), name.c_str());
+}
+
+bool JavaScriptObject::jniHasProperty(jni::alias_ref<jstring> name) {
+  return hasProperty(name->toStdString());
+}
+
+jni::local_ref<JavaScriptValue::javaobject> JavaScriptObject::jniGetProperty(
+  jni::alias_ref<jstring> name
+) {
+  auto result = std::make_shared<jsi::Value>(getProperty(name->toStdString()));
+  return JavaScriptValue::newObjectCxxArgs(runtimeHolder, result);
+}
+
+std::vector<std::string> JavaScriptObject::getPropertyNames() {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+
+  jsi::Array properties = jsObject->getPropertyNames(*runtime->get());
+  auto size = properties.size(*runtime->get());
+
+  std::vector<std::string> names(size);
+  for (size_t i = 0; i < size; i++) {
+    auto propertyName = properties
+      .getValueAtIndex(*runtime->get(), i)
+      .asString(*runtime->get())
+      .utf8(*runtime->get());
+    names[i] = propertyName;
+  }
+
+  return names;
+}
+
+jni::local_ref<jni::JArrayClass<jstring>> JavaScriptObject::jniGetPropertyNames() {
+  std::vector<std::string> cResult = getPropertyNames();
+  auto paredResult = jni::JArrayClass<jstring>::newArray(cResult.size());
+  for (size_t i = 0; i < cResult.size(); i++) {
+    paredResult->setElement(i, jni::make_jstring(cResult[i]).get());
+  }
+
+  return paredResult;
+}
+
+void JavaScriptObject::setProperty(const std::string &name, jsi::Value value) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  jsObject->setProperty(*runtime->get(), name.c_str(), value);
+}
+
+void JavaScriptObject::unsetProperty(jni::alias_ref<jstring> name) {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  auto cName = name->toStdString();
+  jsObject->setProperty(
+    *runtime->get(),
+    cName.c_str(),
+    jsi::Value::undefined()
+  );
+}
+
+jsi::Object JavaScriptObject::preparePropertyDescriptor(
+  jsi::Runtime &jsRuntime,
+  int options
+) {
+  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));
+  return descriptor;
+}
+} // namespace expo

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

@@ -0,0 +1,131 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JSIObjectWrapper.h"
+#include "JSITypeConverter.h"
+#include "JavaScriptRuntime.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+class JavaScriptValue;
+
+class JavaScriptRuntime;
+
+/**
+ * Represents any JavaScript object. Its purpose is to exposes `jsi::Object` API back to Kotlin.
+ */
+class JavaScriptObject : public jni::HybridClass<JavaScriptObject>, JSIObjectWrapper {
+public:
+  static auto constexpr
+    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaScriptObject;";
+  static auto constexpr TAG = "JavaScriptObject";
+
+  static void registerNatives();
+
+  JavaScriptObject(
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Object> jsObject
+  );
+
+  std::shared_ptr<jsi::Object> get() override;
+
+  /**
+   * @return a bool whether the object has a property with the given name
+   */
+  bool hasProperty(const std::string &name);
+
+  /**
+   * @return the property of the object with the given name.
+   * If the name isn't a property on the object, returns the `jsi::Value::undefined` value.
+   */
+  jsi::Value getProperty(const std::string &name);
+
+  /**
+   * @return a vector consisting of all enumerable property names in the object and its prototype chain.
+   */
+  std::vector<std::string> getPropertyNames();
+
+  void setProperty(const std::string &name, jsi::Value value);
+
+private:
+  friend HybridBase;
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
+  std::shared_ptr<jsi::Object> jsObject;
+
+  bool jniHasProperty(jni::alias_ref<jstring> name);
+
+  jni::local_ref<jni::HybridClass<JavaScriptValue>::javaobject> jniGetProperty(
+    jni::alias_ref<jstring> name
+  );
+
+  jni::local_ref<jni::JArrayClass<jstring>> jniGetPropertyNames();
+
+  /**
+   * Unsets property with the given name.
+   */
+  void unsetProperty(jni::alias_ref<jstring> name);
+
+  /**
+   * A template to generate different versions of the `setProperty` method based on the `jsi_type_converter` trait.
+   * Those generated methods will be exported and visible in the Kotlin codebase.
+   * On the other hand, we could just make one function that would take a generic Java Object,
+   * but then we would have to decide what to do with it and how to convert it to jsi::Value
+   * in cpp. That would be expensive. So it's easier to ensure that
+   * we call the correct version of `setProperty` in the Kotlin code.
+   *
+   * This template will work only if the jsi_type_converter exists for a given type.
+   */
+  template<
+    class T,
+    typename = std::enable_if_t<is_jsi_type_converter_defined<T>>
+  >
+  void setProperty(jni::alias_ref<jstring> name, T value) {
+    auto runtime = runtimeHolder.lock();
+    assert(runtime != nullptr);
+    auto cName = name->toStdString();
+
+    jsObject->setProperty(
+      *runtime->get(),
+      cName.c_str(),
+      jsi_type_converter<T>::convert(*runtime->get(), value)
+    );
+  }
+
+  template<
+    class T,
+    typename = std::enable_if_t<is_jsi_type_converter_defined<T>>
+  >
+  void defineProperty(jni::alias_ref<jstring> name, T value, int options) {
+    auto runtime = runtimeHolder.lock();
+    assert(runtime != nullptr);
+    jsi::Runtime &jsRuntime = *runtime->get();
+
+    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)
+    });
+  }
+
+  static jsi::Object preparePropertyDescriptor(jsi::Runtime &jsRuntime, int options);
+};
+} // namespace expo

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

@@ -0,0 +1,127 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JavaScriptRuntime.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+#include "Exceptions.h"
+
+#if FOR_HERMES
+
+#include <hermes/hermes.h>
+
+#include <utility>
+
+#else
+
+#include <jsi/JSCRuntime.h>
+
+#endif
+
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+void SyncCallInvoker::invokeAsync(std::function<void()> &&func) {
+  func();
+}
+
+void SyncCallInvoker::invokeSync(std::function<void()> &&func) {
+  func();
+}
+
+JavaScriptRuntime::JavaScriptRuntime()
+  : jsInvoker(std::make_shared<SyncCallInvoker>()),
+    nativeInvoker(std::make_shared<SyncCallInvoker>()) {
+#if FOR_HERMES
+  auto config = ::hermes::vm::RuntimeConfig::Builder()
+    .withEnableSampleProfiling(false);
+  runtime = facebook::hermes::makeHermesRuntime(config.build());
+
+  // By default "global" property isn't set in the Hermes.
+  runtime->global().setProperty(
+    *runtime,
+    jsi::PropNameID::forUtf8(*runtime, "global"),
+    runtime->global()
+  );
+
+  // This version of the Hermes uses a Promise implementation that is provided by the RN.
+  // The `setImmediate` function isn't defined, but is required by the Promise implementation.
+  // That's why we inject it here.
+  auto setImmediatePropName = jsi::PropNameID::forUtf8(*runtime, "setImmediate");
+  runtime->global().setProperty(
+    *runtime,
+    setImmediatePropName,
+    jsi::Function::createFromHostFunction(
+      *runtime,
+      setImmediatePropName,
+      1,
+      [](jsi::Runtime &rt,
+         const jsi::Value &thisVal,
+         const jsi::Value *args,
+         size_t count) {
+        args[0].asObject(rt).asFunction(rt).call(rt);
+        return jsi::Value::undefined();
+      }
+    )
+  );
+#else
+  runtime = facebook::jsc::makeJSCRuntime();
+#endif
+}
+
+JavaScriptRuntime::JavaScriptRuntime(
+  jsi::Runtime *runtime,
+  std::shared_ptr<react::CallInvoker> jsInvoker,
+  std::shared_ptr<react::CallInvoker> nativeInvoker
+) : jsInvoker(std::move(jsInvoker)), nativeInvoker(std::move(nativeInvoker)) {
+  // 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
+  this->runtime = std::shared_ptr<jsi::Runtime>(std::shared_ptr<jsi::Runtime>(), runtime);
+}
+
+jsi::Runtime *JavaScriptRuntime::get() {
+  return runtime.get();
+}
+
+jni::local_ref<JavaScriptValue::javaobject>
+JavaScriptRuntime::evaluateScript(const std::string &script) {
+  auto scriptBuffer = std::make_shared<jsi::StringBuffer>(script);
+  std::shared_ptr<jsi::Value> result;
+  try {
+    result = std::make_shared<jsi::Value>(
+      runtime->evaluateJavaScript(scriptBuffer, "<<evaluated>>")
+    );
+  } catch (const jsi::JSError &error) {
+    jni::throwNewJavaException(
+      JavaScriptEvaluateException::create(
+        error.getMessage(),
+        error.getStack()
+      ).get()
+    );
+  } catch (const jsi::JSIException &error) {
+    jni::throwNewJavaException(
+      JavaScriptEvaluateException::create(
+        error.what(),
+        ""
+      ).get()
+    );
+  }
+
+  return JavaScriptValue::newObjectCxxArgs(weak_from_this(), result);
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JavaScriptRuntime::global() {
+  auto global = std::make_shared<jsi::Object>(runtime->global());
+  return JavaScriptObject::newObjectCxxArgs(weak_from_this(), global);
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JavaScriptRuntime::createObject() {
+  auto newObject = std::make_shared<jsi::Object>(*runtime);
+  return JavaScriptObject::newObjectCxxArgs(weak_from_this(), newObject);
+}
+
+void JavaScriptRuntime::drainJSEventLoop() {
+  while (!runtime->drainMicrotasks()) {}
+}
+} // namespace expo

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

@@ -0,0 +1,87 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <fbjni/fbjni.h>
+#include <ReactCommon/CallInvoker.h>
+
+namespace jsi = facebook::jsi;
+namespace jni = facebook::jni;
+namespace react = facebook::react;
+
+namespace expo {
+class JavaScriptValue;
+
+class JavaScriptObject;
+
+/**
+ * Dummy CallInvoker that invokes everything immediately.
+ * Used in the test environment to check the async flow.
+ */
+class SyncCallInvoker : public react::CallInvoker {
+public:
+  void invokeAsync(std::function<void()> &&func) override;
+
+  void invokeSync(std::function<void()> &&func) override;
+
+  ~SyncCallInvoker() override = default;
+};
+
+/**
+ * A wrapper for the jsi::Runtime.
+ * This class is used as a bridge between CPP and Kotlin and to encapsulate common runtime helper functions.
+ *
+ * Instances of this class should be managed using a shared smart pointer.
+ * To pass runtime information to all of `JavaScriptValue` and `JavaScriptObject` we use `weak_from_this()`
+ * that requires that the object is held via a smart pointer. Otherwise, `weak_from_this()` returns `nullptr`.
+ */
+class JavaScriptRuntime : public std::enable_shared_from_this<JavaScriptRuntime> {
+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(
+    jsi::Runtime *runtime,
+    std::shared_ptr<react::CallInvoker> jsInvoker,
+    std::shared_ptr<react::CallInvoker> nativeInvoker
+  );
+
+  /**
+   * Returns the underlying runtime object.
+   */
+  jsi::Runtime *get();
+
+  /**
+   * Evaluates given JavaScript source code.
+   * @throws if the input format is unknown, or evaluation causes an error,
+   * a jni::JniException<JavaScriptEvaluateException> will be thrown.
+   */
+  jni::local_ref<jni::HybridClass<JavaScriptValue>::javaobject> evaluateScript(
+    const std::string &script
+  );
+
+  /**
+   * Returns the runtime global object for use in Kotlin.
+   */
+  jni::local_ref<jni::HybridClass<JavaScriptObject>::javaobject> global();
+
+  /**
+   * Creates a new object for use in Kotlin.
+   */
+  jni::local_ref<jni::HybridClass<JavaScriptObject>::javaobject> createObject();
+
+  /**
+   * Drains the JavaScript VM internal Microtask (a.k.a. event loop) queue.
+   */
+  void drainJSEventLoop();
+
+  std::shared_ptr<react::CallInvoker> jsInvoker;
+  std::shared_ptr<react::CallInvoker> nativeInvoker;
+private:
+  std::shared_ptr<jsi::Runtime> runtime;
+};
+} // namespace expo

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

@@ -0,0 +1,172 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JavaScriptValue.h"
+
+#include "JavaScriptRuntime.h"
+#include "JavaScriptObject.h"
+
+namespace expo {
+void JavaScriptValue::registerNatives() {
+  registerHybrid({
+                   makeNativeMethod("kind", JavaScriptValue::jniKind),
+                   makeNativeMethod("isNull", JavaScriptValue::isNull),
+                   makeNativeMethod("isUndefined", JavaScriptValue::isUndefined),
+                   makeNativeMethod("isBool", JavaScriptValue::isBool),
+                   makeNativeMethod("isNumber", JavaScriptValue::isNumber),
+                   makeNativeMethod("isString", JavaScriptValue::isString),
+                   makeNativeMethod("isSymbol", JavaScriptValue::isSymbol),
+                   makeNativeMethod("isFunction", JavaScriptValue::isFunction),
+                   makeNativeMethod("isArray", JavaScriptValue::isArray),
+                   makeNativeMethod("isObject", JavaScriptValue::isObject),
+                   makeNativeMethod("getBool", JavaScriptValue::getBool),
+                   makeNativeMethod("getDouble", JavaScriptValue::getDouble),
+                   makeNativeMethod("getString", JavaScriptValue::jniGetString),
+                   makeNativeMethod("getObject", JavaScriptValue::getObject),
+                   makeNativeMethod("getArray", JavaScriptValue::getArray),
+                 });
+}
+
+JavaScriptValue::JavaScriptValue(
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Value> jsValue
+) : runtimeHolder(std::move(runtime)), jsValue(std::move(jsValue)) {
+  assert(runtimeHolder.lock() != nullptr);
+}
+
+std::shared_ptr<jsi::Value> JavaScriptValue::get() {
+  return jsValue;
+}
+
+std::string JavaScriptValue::kind() {
+  if (isNull()) {
+    return "null";
+  }
+  if (isUndefined()) {
+    return "undefined";
+  }
+  if (isBool()) {
+    return "boolean";
+  }
+  if (isNumber()) {
+    return "number";
+  }
+  if (isString()) {
+    return "string";
+  }
+  if (isSymbol()) {
+    return "symbol";
+  }
+  if (isFunction()) {
+    return "function";
+  }
+  if (isArray()) {
+    return "array";
+  }
+  if (isObject()) {
+    return "object";
+  }
+
+  // TODO(@lukmccall): maybe throw exception?
+  return "unknown";
+}
+
+bool JavaScriptValue::isNull() {
+  return jsValue->isNull();
+}
+
+bool JavaScriptValue::isUndefined() {
+  return jsValue->isUndefined();
+}
+
+bool JavaScriptValue::isBool() {
+  return jsValue->isBool();
+}
+
+bool JavaScriptValue::isNumber() {
+  return jsValue->isNumber();
+}
+
+bool JavaScriptValue::isString() {
+  return jsValue->isString();
+}
+
+bool JavaScriptValue::isSymbol() {
+  return jsValue->isSymbol();
+}
+
+bool JavaScriptValue::isFunction() {
+  if (jsValue->isObject()) {
+    auto runtime = runtimeHolder.lock();
+    assert(runtime != nullptr);
+    return jsValue->asObject(*runtime->get()).isFunction(*runtime->get());
+  }
+
+  return false;
+}
+
+bool JavaScriptValue::isArray() {
+  if (jsValue->isObject()) {
+    auto runtime = runtimeHolder.lock();
+    assert(runtime != nullptr);
+    return jsValue->asObject(*runtime->get()).isArray(*runtime->get());
+  }
+
+  return false;
+}
+
+bool JavaScriptValue::isObject() {
+  return jsValue->isObject();
+}
+
+bool JavaScriptValue::getBool() {
+  return jsValue->getBool();
+}
+
+double JavaScriptValue::getDouble() {
+  return jsValue->getNumber();
+}
+
+std::string JavaScriptValue::getString() {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  return jsValue->getString(*runtime->get()).utf8(*runtime->get());
+}
+
+jni::local_ref<JavaScriptObject::javaobject> JavaScriptValue::getObject() {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+  auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(*runtime->get()));
+  return JavaScriptObject::newObjectCxxArgs(runtimeHolder, jsObject);
+}
+
+jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptValue::getArray() {
+  auto runtime = runtimeHolder.lock();
+  assert(runtime != nullptr);
+
+  auto jsArray = jsValue
+    ->getObject(*runtime->get())
+    .asArray(*runtime->get());
+  size_t size = jsArray.size(*runtime->get());
+
+  auto result = jni::JArrayClass<JavaScriptValue::javaobject>::newArray(size);
+  for (size_t i = 0; i < size; i++) {
+    auto element = JavaScriptValue::newObjectCxxArgs(
+      runtimeHolder,
+      std::make_shared<jsi::Value>(jsArray.getValueAtIndex(*runtime->get(), i))
+    );
+
+    result->setElement(i, element.release());
+  }
+  return result;
+}
+
+jni::local_ref<jstring> JavaScriptValue::jniKind() {
+  auto result = kind();
+  return jni::make_jstring(result);
+}
+
+jni::local_ref<jstring> JavaScriptValue::jniGetString() {
+  auto result = getString();
+  return jni::make_jstring(result);
+}
+} // namespace expo