expo-modules-core 0.9.2 → 0.11.1

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());
+
+  // 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
+
+  // By default "global" property isn't set.
+  runtime->global().setProperty(
+    *runtime,
+    jsi::PropNameID::forUtf8(*runtime, "global"),
+    runtime->global()
+  );
+}
+
+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

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

@@ -0,0 +1,78 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "JSIObjectWrapper.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+class JavaScriptRuntime;
+
+class JavaScriptObject;
+
+/**
+ * Represents any JavaScript value. Its purpose is to expose the `jsi::Value` API back to Kotlin.
+ */
+class JavaScriptValue : public jni::HybridClass<JavaScriptValue>, JSIValueWrapper {
+public:
+  static auto constexpr
+    kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaScriptValue;";
+  static auto constexpr TAG = "JavaScriptValue";
+
+  static void registerNatives();
+
+  JavaScriptValue(
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Value> jsValue
+  );
+
+  std::shared_ptr<jsi::Value> get() override;
+
+  std::string kind();
+
+  bool isNull();
+
+  bool isUndefined();
+
+  bool isBool();
+
+  bool isNumber();
+
+  bool isString();
+
+  bool isSymbol();
+
+  bool isFunction();
+
+  bool isArray();
+
+  bool isObject();
+
+  bool getBool();
+
+  double getDouble();
+
+  std::string getString();
+
+  jni::local_ref<jni::HybridClass<JavaScriptObject>::javaobject> getObject();
+
+  jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> getArray();
+
+private:
+  friend HybridBase;
+
+  std::weak_ptr<JavaScriptRuntime> runtimeHolder;
+  std::shared_ptr<jsi::Value> jsValue;
+
+  jni::local_ref<jstring> jniKind();
+
+  jni::local_ref<jstring> jniGetString();
+};
+} // namespace expo