expo-modules-core 0.9.0 → 0.10.0

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

package/android/src/main/cpp/MethodMetadata.cpp

@@ -0,0 +1,230 @@
+#include "MethodMetadata.h"
+
+#include "JSIInteropModuleRegistry.h"
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+
+// Modified version of the RN implementation
+// https://github.com/facebook/react-native/blob/7dceb9b63c0bfd5b13bf6d26f9530729506e9097/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp#L57
+jni::local_ref<react::JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
+  jsi::Function &&function,
+  jsi::Runtime &rt,
+  std::shared_ptr<react::CallInvoker> jsInvoker
+) {
+  auto weakWrapper = react::CallbackWrapper::createWeak(std::move(function), rt,
+                                                        std::move(jsInvoker));
+
+  // This needs to be a shared_ptr because:
+  // 1. It cannot be unique_ptr. std::function is copyable but unique_ptr is
+  // not.
+  // 2. It cannot be weak_ptr since we need this object to live on.
+  // 3. It cannot be a value, because that would be deleted as soon as this
+  // function returns.
+  auto callbackWrapperOwner =
+    std::make_shared<react::RAIICallbackWrapperDestroyer>(weakWrapper);
+
+  std::function<void(folly::dynamic)> fn =
+    [weakWrapper, callbackWrapperOwner, wrapperWasCalled = false](
+      folly::dynamic responses) mutable {
+      if (wrapperWasCalled) {
+        throw std::runtime_error(
+          "callback 2 arg cannot be called more than once");
+      }
+
+      auto strongWrapper = weakWrapper.lock();
+      if (!strongWrapper) {
+        return;
+      }
+
+      strongWrapper->jsInvoker().invokeAsync(
+        [weakWrapper, callbackWrapperOwner, responses]() mutable {
+          auto strongWrapper2 = weakWrapper.lock();
+          if (!strongWrapper2) {
+            return;
+          }
+
+          jsi::Value args =
+            jsi::valueFromDynamic(strongWrapper2->runtime(), responses);
+          auto argsArray = args.getObject(strongWrapper2->runtime())
+            .asArray(strongWrapper2->runtime());
+          jsi::Value arg = argsArray.getValueAtIndex(strongWrapper2->runtime(), 0);
+
+          strongWrapper2->callback().call(
+            strongWrapper2->runtime(),
+            (const jsi::Value *) &arg,
+            (size_t) 1
+          );
+
+          callbackWrapperOwner.reset();
+        });
+
+      wrapperWasCalled = true;
+    };
+
+  return react::JCxxCallbackImpl::newObjectCxxArgs(fn);
+}
+
+MethodMetadata::MethodMetadata(
+  std::string name,
+  int args,
+  bool isAsync,
+  jni::global_ref<jobject> &&jBodyReference
+) : name(name),
+    args(args),
+    isAsync(isAsync),
+    jBodyReference(jBodyReference) {}
+
+std::shared_ptr<jsi::Function> MethodMetadata::toJSFunction(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry
+) {
+  if (body == nullptr) {
+    if (isAsync) {
+      body = std::make_shared<jsi::Function>(toAsyncFunction(runtime, moduleRegistry));
+    } else {
+      body = std::make_shared<jsi::Function>(toSyncFunction(runtime));
+    }
+  }
+
+  return body;
+}
+
+jsi::Function MethodMetadata::toSyncFunction(jsi::Runtime &runtime) {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, name),
+    args,
+    [this](
+      jsi::Runtime &rt,
+      const jsi::Value &thisValue,
+      const jsi::Value *args,
+      size_t count
+    ) -> jsi::Value {
+      auto dynamicArray = folly::dynamic::array();
+      for (int i = 0; i < count; i++) {
+        auto &arg = args[i];
+        dynamicArray.push_back(jsi::dynamicFromValue(rt, arg));
+      }
+
+      // Cast in this place is safe, cause we know that this function is promise-less.
+      auto syncFunction = jni::static_ref_cast<JNIFunctionBody>(this->jBodyReference);
+      auto result = syncFunction->invoke(
+        react::ReadableNativeArray::newObjectCxxArgs(std::move(dynamicArray)).get()
+      );
+
+      if (result == nullptr) {
+        return jsi::Value::undefined();
+      }
+
+      return jsi::valueFromDynamic(rt, result->cthis()->consume())
+        .asObject(rt)
+        .asArray(rt)
+        .getValueAtIndex(rt, 0);
+    });
+}
+
+jsi::Function MethodMetadata::toAsyncFunction(
+  jsi::Runtime &runtime, 
+  JSIInteropModuleRegistry *moduleRegistry
+) {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, name),
+    args,
+    [this, moduleRegistry](
+      jsi::Runtime &rt,
+      const jsi::Value &thisValue,
+      const jsi::Value *args,
+      size_t count
+    ) -> jsi::Value {
+      auto dynamicArray = folly::dynamic::array();
+      for (int i = 0; i < count; i++) {
+        auto &arg = args[i];
+        dynamicArray.push_back(jsi::dynamicFromValue(rt, arg));
+      }
+
+      auto Promise = rt.global().getPropertyAsFunction(rt, "Promise");
+      // Creates a JSI promise
+      jsi::Value promise = Promise.callAsConstructor(
+        rt,
+        createPromiseBody(rt, moduleRegistry, std::move(dynamicArray))
+      );
+      return promise;
+    }
+  );
+}
+
+jsi::Function MethodMetadata::createPromiseBody(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry,
+  folly::dynamic &&args
+) {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, "promiseFn"),
+    2,
+    [this, args = std::move(args), moduleRegistry](
+      jsi::Runtime &rt,
+      const jsi::Value &thisVal,
+      const jsi::Value *promiseConstructorArgs,
+      size_t promiseConstructorArgCount
+    ) {
+      if (promiseConstructorArgCount != 2) {
+        throw std::invalid_argument("Promise fn arg count must be 2");
+      }
+
+      jsi::Function resolveJSIFn = promiseConstructorArgs[0].getObject(rt).getFunction(rt);
+      jsi::Function rejectJSIFn = promiseConstructorArgs[1].getObject(rt).getFunction(rt);
+
+      auto &runtimeHolder = moduleRegistry->runtimeHolder;
+      jobject resolve = createJavaCallbackFromJSIFunction(
+        std::move(resolveJSIFn),
+        rt,
+        runtimeHolder->jsInvoker
+      ).release();
+
+      jobject reject = createJavaCallbackFromJSIFunction(
+        std::move(rejectJSIFn),
+        rt,
+        runtimeHolder->jsInvoker
+      ).release();
+
+      JNIEnv *env = jni::Environment::current();
+
+      jclass jPromiseImpl =
+        env->FindClass("com/facebook/react/bridge/PromiseImpl");
+      jmethodID jPromiseImplConstructor = env->GetMethodID(
+        jPromiseImpl,
+        "<init>",
+        "(Lcom/facebook/react/bridge/Callback;Lcom/facebook/react/bridge/Callback;)V");
+
+      // Creates a promise object
+      jobject promise = env->NewObject(
+        jPromiseImpl,
+        jPromiseImplConstructor,
+        resolve,
+        reject
+      );
+
+      // Cast in this place is safe, cause we know that this function expects promise.
+      auto asyncFunction = jni::static_ref_cast<JNIAsyncFunctionBody>(this->jBodyReference);
+      asyncFunction->invoke(
+        react::ReadableNativeArray::newObjectCxxArgs(args).get(),
+        promise
+      );
+
+      // We have to remove the local reference to the promise object.
+      // It doesn't mean that the promise will be deallocated, but rather that we move
+      // the ownership to the `JNIAsyncFunctionBody`.
+      env->DeleteLocalRef(promise);
+
+      return jsi::Value::undefined();
+    }
+  );
+}
+
+} // namespace expo

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

@@ -0,0 +1,92 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <fbjni/fbjni.h>
+#include <ReactCommon/TurboModuleUtils.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <memory>
+#include <folly/dynamic.h>
+#include <jsi/JSIDynamic.h>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+class JSIInteropModuleRegistry;
+
+/**
+ * A class that holds information about the exported function.
+ */
+class MethodMetadata {
+public:
+  /**
+   * Function name
+   */
+  std::string name;
+  /**
+   * Number of arguments
+   */
+  int args;
+  /*
+   * Whether this function is async
+   */
+  bool isAsync;
+
+  MethodMetadata(
+    std::string name,
+    int args,
+    bool isAsync,
+    jni::global_ref<jobject> &&jBodyReference
+  );
+
+  // We deleted the copy contractor to not deal with transforming the ownership of the `jBodyReference`.
+  MethodMetadata(const MethodMetadata &) = delete;
+
+  /**
+   * MethodMetadata owns the only reference to the Kotlin function.
+   * We have to clean that, cause it's a `global_ref`.
+   */
+  ~MethodMetadata() {
+    jBodyReference.release();
+  }
+
+  /**
+   * Transforms metadata to a jsi::Function.
+   *
+   * @param runtime
+   * @param moduleRegistry
+   * @return shared ptr to the jsi::Function that wrapped the underlying Kotlin's function.
+   */
+  std::shared_ptr<jsi::Function> toJSFunction(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *moduleRegistry
+  );
+
+private:
+  /**
+   * Reference to one of two java objects - `JNIFunctionBody` or `JNIAsyncFunctionBody`.
+   *
+   * In case when `isAsync` is `true`, this variable will point to `JNIAsyncFunctionBody`.
+   * Otherwise to `JNIFunctionBody`
+   */
+  jni::global_ref<jobject> jBodyReference;
+
+  /**
+   * To not create a jsi::Function always when we need it, we cached that value.
+   */
+  std::shared_ptr<jsi::Function> body = nullptr;
+
+  jsi::Function toSyncFunction(jsi::Runtime &runtime);
+
+  jsi::Function toAsyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
+
+  jsi::Function createPromiseBody(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *moduleRegistry,
+    folly::dynamic &&args
+  );
+};
+} // namespace expo

package/android/src/main/java/expo/modules/adapters/react/NativeModulesProxy.java

@@ -92,6 +92,8 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
   @Override
   public Map<String, Object> getConstants() {
     mModuleRegistry.ensureIsInitialized();
+    getKotlinInteropModuleRegistry().installJSIInterop();
+
     Collection<ExportedModule> exportedModules = mModuleRegistry.getAllExportedModules();
     Collection<ViewManager> viewManagers = mModuleRegistry.getAllViewManagers();
 

package/android/src/main/java/expo/modules/core/errors/ContextDestroyedException.kt

@@ -0,0 +1,7 @@
+package expo.modules.core.errors
+
+import kotlinx.coroutines.CancellationException
+
+private const val DEFAULT_MESSAGE = "App context destroyed. All coroutines are cancelled."
+
+class ContextDestroyedException(message: String = DEFAULT_MESSAGE) : CancellationException(message)

package/android/src/main/java/expo/modules/interfaces/permissions/Permissions.java

@@ -1,5 +1,7 @@
 package expo.modules.interfaces.permissions;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import expo.modules.core.Promise;
 
 public interface Permissions {
@@ -12,6 +14,20 @@ public interface Permissions {
     permissionsManager.getPermissionsWithPromise(promise, permissions);
   }
 
+  /**
+   * Compatibility method that accepts expo.modules.kotlin.Promise, but forward the logic to the other method
+   */
+  static void getPermissionsWithPermissionsManager(
+    @Nullable Permissions permissionsManager,
+    @NonNull final expo.modules.kotlin.Promise promise,
+    @NonNull String... permissions
+  ) {
+    getPermissionsWithPermissionsManager(permissionsManager, new Promise() {
+      @Override public void resolve(Object value) { promise.resolve(value); }
+      @Override public void reject(String c, String m, Throwable e) { promise.reject(c, m, e); }
+    }, permissions);
+  }
+
   static void askForPermissionsWithPermissionsManager(Permissions permissionsManager, final Promise promise, String... permissions) {
     if (permissionsManager == null) {
       promise.reject("E_NO_PERMISSIONS", "Permissions module is null. Are you sure all the installed Expo modules are properly linked?");
@@ -20,6 +36,20 @@ public interface Permissions {
     permissionsManager.askForPermissionsWithPromise(promise, permissions);
   }
 
+  /**
+   * Compatibility method that accepts expo.modules.kotlin.Promise, but forward the logic to the other method
+   */
+  static void askForPermissionsWithPermissionsManager(
+    @Nullable Permissions permissionsManager,
+    @NonNull final expo.modules.kotlin.Promise promise,
+    @NonNull String... permissions
+  ) {
+    askForPermissionsWithPermissionsManager(permissionsManager, new Promise() {
+      @Override public void resolve(Object value) { promise.resolve(value); }
+      @Override public void reject(String c, String m, Throwable e) { promise.reject(c, m, e); }
+    }, permissions);
+  }
+
   void getPermissionsWithPromise(final Promise promise, String... permissions);
 
   void getPermissions(final PermissionsResponseListener response, String... permissions);

package/android/src/main/java/expo/modules/kotlin/AppContext.kt

@@ -1,9 +1,14 @@
+@file:OptIn(DelicateCoroutinesApi::class)
+
 package expo.modules.kotlin
 
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
+import androidx.appcompat.app.AppCompatActivity
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import expo.modules.core.errors.ContextDestroyedException
 import expo.modules.core.interfaces.ActivityProvider
 import expo.modules.interfaces.barcodescanner.BarCodeScannerInterface
 import expo.modules.interfaces.camera.CameraViewInterface
@@ -20,19 +25,34 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.KEventEmitterWrapper
 import expo.modules.kotlin.events.KModuleEventEmitterWrapper
 import expo.modules.kotlin.events.OnActivityResultPayload
+import expo.modules.kotlin.jni.JSIInteropModuleRegistry
 import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.providers.CurrentActivityProvider
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.newSingleThreadContext
 import java.lang.ref.WeakReference
 
 class AppContext(
   modulesProvider: ModulesProvider,
   val legacyModuleRegistry: expo.modules.core.ModuleRegistry,
   private val reactContextHolder: WeakReference<ReactApplicationContext>
-) {
+) : CurrentActivityProvider {
   val registry = ModuleRegistry(WeakReference(this)).apply {
     register(ErrorManagerModule())
     register(modulesProvider)
   }
   private val reactLifecycleDelegate = ReactLifecycleDelegate(this)
+  // We postpone creating the `JSIInteropModuleRegistry` to not load so files in unit tests.
+  private lateinit var jsiInterop: JSIInteropModuleRegistry
+  internal val modulesQueue = CoroutineScope(
+    newSingleThreadContext("ExpoModulesCoreQueue") +
+      SupervisorJob() +
+      CoroutineName("ExpoModulesCoreCoroutineQueue")
+  )
 
   init {
     requireNotNull(reactContextHolder.get()) {
@@ -43,6 +63,18 @@ class AppContext(
     }
   }
 
+  fun installJSIInterop() {
+    jsiInterop = JSIInteropModuleRegistry(this)
+    val reactContext = reactContextHolder.get() ?: return
+    reactContext.javaScriptContextHolder?.get()?.let {
+      jsiInterop.installJSI(
+        it,
+        reactContext.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl,
+        reactContext.catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
+      )
+    }
+  }
+
   /**
    * Returns a legacy module implementing given interface.
    */
@@ -149,6 +181,7 @@ class AppContext(
     reactContextHolder.get()?.removeLifecycleEventListener(reactLifecycleDelegate)
     registry.post(EventName.MODULE_DESTROY)
     registry.cleanUp()
+    modulesQueue.cancel(ContextDestroyedException())
   }
 
   fun onHostResume() {
@@ -181,4 +214,19 @@ class AppContext(
       intent
     )
   }
+
+// region CurrentActivityProvider
+
+  override val currentActivity: AppCompatActivity?
+    get() {
+      val currentActivity = this.activityProvider?.currentActivity ?: return null
+
+      check(currentActivity is AppCompatActivity) {
+        "Current Activity is of incorrect class, expected AppCompatActivity, received ${currentActivity.localClassName}"
+      }
+
+      return currentActivity
+    }
+
+// endregion
 }

package/android/src/main/java/expo/modules/kotlin/ConcatIterator.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin
+
+/**
+ * Simple iterator that will merge two other iterators.
+ */
+class ConcatIterator<T>(
+  private val first: Iterator<T>,
+  private val second: Iterator<T>
+) : Iterator<T> {
+  override fun hasNext(): Boolean = first.hasNext() || second.hasNext()
+
+  override fun next(): T =
+    if (first.hasNext()) {
+      first.next()
+    } else {
+      second.next()
+    }
+}

package/android/src/main/java/expo/modules/kotlin/KotlinInteropModuleRegistry.kt

@@ -41,26 +41,25 @@ class KotlinInteropModuleRegistry(
   }
 
   fun exportedModulesConstants(): Map<ModuleName, ModuleConstants> {
-    return registry
-      .map { holder ->
-        holder.name to holder.definition.constantsProvider()
-      }
-      .toMap()
+    return registry.associate { holder ->
+      holder.name to holder.definition.constantsProvider()
+    }
   }
 
   fun exportMethods(exportKey: (String, List<ModuleMethodInfo>) -> Unit = { _, _ -> }): Map<ModuleName, List<ModuleMethodInfo>> {
-    return registry
-      .map { holder ->
-        val methodsInfo = holder.definition.methods.map { (name, method) ->
+    return registry.associate { holder ->
+      val methodsInfo = holder
+        .definition
+        .asyncFunctions
+        .map { (name, method) ->
           mapOf(
             "name" to name,
             "argumentsCount" to method.argsCount
           )
         }
-        exportKey(holder.name, methodsInfo)
-        holder.name to methodsInfo
-      }
-      .toMap()
+      exportKey(holder.name, methodsInfo)
+      holder.name to methodsInfo
+    }
   }
 
   fun exportViewManagers(): List<ViewManager<*, *>> {
@@ -110,4 +109,8 @@ class KotlinInteropModuleRegistry(
   fun onDestroy() {
     appContext.onDestroy()
   }
+
+  fun installJSIInterop() {
+    appContext.installJSIInterop()
+  }
 }

package/android/src/main/java/expo/modules/kotlin/ModuleHolder.kt

@@ -1,5 +1,6 @@
 package expo.modules.kotlin
 
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableArray
 import expo.modules.kotlin.events.BasicEventListener
 import expo.modules.kotlin.events.EventListenerWithPayload
@@ -8,19 +9,54 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.exception.FunctionCallException
 import expo.modules.kotlin.exception.MethodNotFoundException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ProcessedModuleDefinition
 
 class ModuleHolder(val module: Module) {
-  val definition = module.definition()
+  val definition = ProcessedModuleDefinition(module.definition(), this)
+
   val name get() = definition.name
 
+  /**
+   * Cached instance of HybridObject used by CPP to interact with underlying [expo.modules.kotlin.modules.Module] object.
+   */
+  val jsObject by lazy {
+    JavaScriptModuleObject()
+      .apply {
+        val constants = definition.constantsProvider()
+        val convertedConstants = Arguments.makeNativeMap(constants)
+        exportConstants(convertedConstants)
+
+        definition
+          .functions
+          .forEach { function ->
+            function.attachToJSObject(module.appContext, this)
+          }
+      }
+  }
+
+  /**
+   * Invokes a function with promise. Is used in the bridge implementation of the Sweet API.
+   */
   fun call(methodName: String, args: ReadableArray, promise: Promise) = exceptionDecorator({
     FunctionCallException(methodName, definition.name, it)
   }) {
-    val method = definition.methods[methodName]
+    val method = definition.asyncFunctions[methodName]
+      ?: throw MethodNotFoundException()
+
+    method.call(args, promise)
+  }
+
+  /**
+   * Invokes a function without promise.
+   * `callSync` was added only for test purpose and shouldn't be used anywhere else.
+   */
+  fun callSync(methodName: String, args: ReadableArray): Any? {
+    val method = definition.syncFunctions[methodName]
       ?: throw MethodNotFoundException()
 
-    method.call(this, args, promise)
+    return method.call(args)
   }
 
   fun post(eventName: EventName) {