expo-modules-core 0.9.0 → 0.10.0

package/android/src/main/java/expo/modules/kotlin/defaultmodules/ErrorManagerModule.kt

@@ -9,8 +9,8 @@ private const val onNewException = "ExpoModulesCoreErrorManager.onNewException"
 
 class ErrorManagerModule : Module() {
   override fun definition() = ModuleDefinition {
-    name("ExpoModulesCoreErrorManager")
-    events(onNewException)
+    Name("ExpoModulesCoreErrorManager")
+    Events(onNewException)
   }
 
   fun reportExceptionToLogBox(codedException: CodedException) {

package/android/src/main/java/expo/modules/kotlin/exception/CodedException.kt

@@ -1,6 +1,7 @@
 package expo.modules.kotlin.exception
 
 import com.facebook.react.bridge.ReadableType
+import expo.modules.core.interfaces.DoNotStrip
 import java.util.*
 import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
@@ -8,6 +9,7 @@ import kotlin.reflect.KType
 /**
  * A class for errors specifying its `code` and providing the `description`.
  */
+@DoNotStrip
 open class CodedException(
   message: String?,
   cause: Throwable?
@@ -152,3 +154,14 @@ internal class CollectionElementCastException(
   message = "Cannot cast '${providedType.name}' to '$elementType' required by the collection of type: '$collectionType'.",
   cause
 )
+
+@DoNotStrip
+class JavaScriptEvaluateException(
+  message: String,
+  val jsStack: String
+) : CodedException(
+  message = """
+  Cannot evaluate JavaScript code: $message.
+  $jsStack
+  """.trimIndent()
+)

package/android/src/main/java/expo/modules/kotlin/exception/ExceptionDecorator.kt

@@ -5,6 +5,8 @@ internal inline fun <T> exceptionDecorator(decoratorBlock: (e: CodedException) -
     block()
   } catch (e: CodedException) {
     throw decoratorBlock(e)
+  } catch (e: expo.modules.core.errors.CodedException) {
+    throw decoratorBlock(CodedException(e.code, e.message, e.cause))
   } catch (e: Throwable) {
     throw decoratorBlock(UnexpectedException(e))
   }

package/android/src/main/java/expo/modules/kotlin/functions/AnyFunction.kt

@@ -1,37 +1,37 @@
 package expo.modules.kotlin.functions
 
 import com.facebook.react.bridge.ReadableArray
-import expo.modules.kotlin.ModuleHolder
-import expo.modules.kotlin.Promise
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.exception.ArgumentCastException
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.exception.InvalidArgsNumberException
 import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.iterator
+import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.AnyType
 
+/**
+ * Base class of all exported functions
+ */
 abstract class AnyFunction(
   protected val name: String,
   private val desiredArgsTypes: Array<AnyType>
 ) {
+  internal val argsCount get() = desiredArgsTypes.size
+
+  /**
+   * Tries to convert arguments from RN representation to expected types.
+   *
+   * @return An array of converted arguments
+   * @throws `CodedException` if conversion isn't possible
+   */
   @Throws(CodedException::class)
-  fun call(module: ModuleHolder, args: ReadableArray, promise: Promise) {
+  protected fun convertArgs(args: ReadableArray): Array<out Any?> {
     if (desiredArgsTypes.size != args.size()) {
       throw InvalidArgsNumberException(args.size(), desiredArgsTypes.size)
     }
 
-    val convertedArgs = convertArgs(args)
-    callImplementation(module, convertedArgs, promise)
-  }
-
-  @Throws(CodedException::class)
-  internal abstract fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise)
-
-  val argsCount get() = desiredArgsTypes.size
-
-  @Throws(CodedException::class)
-  private fun convertArgs(args: ReadableArray): Array<out Any?> {
     val finalArgs = Array<Any?>(desiredArgsTypes.size) { null }
     val argIterator = args.iterator()
     desiredArgsTypes
@@ -47,4 +47,9 @@ abstract class AnyFunction(
       }
     return finalArgs
   }
+
+  /**
+   * Attaches current function to the provided js object.
+   */
+  abstract fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject)
 }

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunction.kt

@@ -1,15 +1,37 @@
 package expo.modules.kotlin.functions
 
-import expo.modules.kotlin.ModuleHolder
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.KPromiseWrapper
 import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.types.AnyType
+import kotlinx.coroutines.launch
 
-class AsyncFunction(
+/**
+ * Base class of all function components that require a promise to be called.
+ */
+abstract class AsyncFunction(
   name: String,
-  argsType: Array<AnyType>,
-  private val body: (args: Array<out Any?>) -> Any?
-) : AnyFunction(name, argsType) {
-  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
-    promise.resolve(body(args))
+  desiredArgsTypes: Array<AnyType>
+) : AnyFunction(name, desiredArgsTypes) {
+  @Throws(CodedException::class)
+  abstract fun call(args: ReadableArray, promise: Promise)
+
+  override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
+    jsObject.registerAsyncFunction(name, argsCount) { args, bridgePromise ->
+      val kotlinPromise = KPromiseWrapper(bridgePromise as com.facebook.react.bridge.Promise)
+      appContext.modulesQueue.launch {
+        try {
+          call(args, kotlinPromise)
+        } catch (e: CodedException) {
+          kotlinPromise.reject(e)
+        } catch (e: Throwable) {
+          kotlinPromise.reject(UnexpectedException(e))
+        }
+      }
+    }
   }
 }

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionBuilder.kt

@@ -6,9 +6,9 @@ package expo.modules.kotlin.functions
 import expo.modules.kotlin.types.toAnyType
 import kotlin.reflect.typeOf
 
-class AsyncFunctionBuilder(val name: String) {
+class AsyncFunctionBuilder(@PublishedApi internal val name: String) {
   @PublishedApi
-  internal var function: AnyFunction? = null
+  internal var functionBuilder: SuspendFunctionComponentBuilder? = null
 
   @Deprecated(
     message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
@@ -17,7 +17,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R> suspendBody(crossinline block: suspend () -> R) = SuspendBody(block)
 
   inline fun <reified R> SuspendBody(crossinline block: suspend () -> R) {
-    function = AsyncSuspendFunction(name, arrayOf()) { block() }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf()) { block() }
   }
 
   @Deprecated(
@@ -27,7 +27,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0> suspendBody(crossinline block: suspend (p0: P0) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0> SuspendBody(crossinline block: suspend (p0: P0) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0) }
   }
 
   @Deprecated(
@@ -37,7 +37,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1> suspendBody(crossinline block: suspend (p0: P0, p1: P1) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1> SuspendBody(crossinline block: suspend (p0: P0, p1: P1) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[0] as P1) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[0] as P1) }
   }
 
   @Deprecated(
@@ -47,7 +47,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1, reified P2> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1, reified P2> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2) }
   }
 
   @Deprecated(
@@ -57,7 +57,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
   }
 
   @Deprecated(
@@ -67,7 +67,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
   }
 
   @Deprecated(
@@ -77,7 +77,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
   }
 
   @Deprecated(
@@ -87,7 +87,7 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6) }
   }
 
   @Deprecated(
@@ -97,11 +97,11 @@ class AsyncFunctionBuilder(val name: String) {
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R) = SuspendBody(block)
 
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> SuspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R) {
-    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5, it[6] as P6, it[7] as P7) }
   }
 
-  internal fun build(): Pair<String, AnyFunction> {
-    return name to requireNotNull(function)
+  internal fun build(): SuspendFunctionComponentBuilder {
+    return requireNotNull(functionBuilder)
   }
 }
 

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionComponent.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin.functions
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.types.AnyType
+
+class AsyncFunctionComponent(
+  name: String,
+  desiredArgsTypes: Array<AnyType>,
+  private val body: (args: Array<out Any?>) -> Any?
+) : AsyncFunction(name, desiredArgsTypes) {
+  @Throws(CodedException::class)
+  override fun call(args: ReadableArray, promise: Promise) {
+    val convertedArgs = convertArgs(args)
+    promise.resolve(body(convertedArgs))
+  }
+}

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionWithPromiseComponent.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin.functions
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.types.AnyType
+
+class AsyncFunctionWithPromiseComponent(
+  name: String,
+  desiredArgsTypes: Array<AnyType>,
+  private val body: (args: Array<out Any?>, promise: Promise) -> Unit
+) : AsyncFunction(name, desiredArgsTypes) {
+  @Throws(CodedException::class)
+  override fun call(args: ReadableArray, promise: Promise) {
+    val convertedArgs = convertArgs(args)
+    body(convertedArgs, promise)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/functions/SuspendFunctionComponent.kt

@@ -0,0 +1,56 @@
+package expo.modules.kotlin.functions
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.FunctionCallException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.types.AnyType
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import java.lang.ref.WeakReference
+import kotlin.jvm.Throws
+
+/**
+ * We can't construct a `SuspendFunctionComponent` in the build phase, because it has to have access to module coroutine scope.
+ * So we create another builder to store needed information and build it later - during the holder initialization.
+ */
+class SuspendFunctionComponentBuilder(
+  internal val name: String,
+  private val desiredArgsTypes: Array<AnyType>,
+  private val body: suspend CoroutineScope.(args: Array<out Any?>) -> Any?,
+) {
+  fun build(moduleHolder: ModuleHolder) =
+    SuspendFunctionComponent(name, desiredArgsTypes, WeakReference(moduleHolder), body)
+}
+
+class SuspendFunctionComponent(
+  name: String,
+  desiredArgsTypes: Array<AnyType>,
+  private val moduleHolderRef: WeakReference<ModuleHolder>,
+  private val body: suspend CoroutineScope.(args: Array<out Any?>) -> Any?
+) : AsyncFunction(name, desiredArgsTypes) {
+  @Throws(CodedException::class)
+  override fun call(args: ReadableArray, promise: Promise) {
+    val holder = moduleHolderRef.get() ?: return
+    val scope = holder.module.coroutineScopeDelegate.value
+    val convertedArgs = convertArgs(args)
+    scope.launch {
+      try {
+        val result = exceptionDecorator({ cause -> FunctionCallException(name, holder.name, cause) }) {
+          body.invoke(scope, convertedArgs)
+        }
+        if (isActive) {
+          promise.resolve(result)
+        }
+      } catch (e: CodedException) {
+        promise.reject(e)
+      } catch (e: Throwable) {
+        promise.reject(UnexpectedException(e))
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/functions/SyncFunctionComponent.kt

@@ -0,0 +1,28 @@
+package expo.modules.kotlin.functions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.jni.JavaScriptModuleObject
+import expo.modules.kotlin.types.AnyType
+import expo.modules.kotlin.types.JSTypeConverter
+
+class SyncFunctionComponent(
+  name: String,
+  desiredArgsTypes: Array<AnyType>,
+  private val body: (args: Array<out Any?>) -> Any?
+) : AnyFunction(name, desiredArgsTypes) {
+  @Throws(CodedException::class)
+  fun call(args: ReadableArray): Any? {
+    return body(convertArgs(args))
+  }
+
+  override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
+    jsObject.registerSyncFunction(name, argsCount) { args ->
+      val result = call(args)
+      val convertedResult = JSTypeConverter.convertToJSValue(result)
+      return@registerSyncFunction Arguments.fromJavaArgs(arrayOf(convertedResult))
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/jni/CppType.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin.jni
+
+private var nextValue = 0
+
+private fun nextValue(): Int = (1 shl nextValue).also { nextValue++ }
+
+/**
+ * Enum that represents Cpp types. Objects of those types can be obtained via JNI.
+ */
+enum class CppType(val value: Int) {
+  DOUBLE(nextValue()),
+  BOOLEAN(nextValue()),
+  STRING(nextValue()),
+  JS_OBJECT(nextValue()),
+  JS_VALUE(nextValue()),
+  READABLE_ARRAY(nextValue()),
+  READABLE_MAP(nextValue());
+}

package/android/src/main/java/expo/modules/kotlin/jni/JNIFunctionBody.kt

@@ -0,0 +1,39 @@
+package expo.modules.kotlin.jni
+
+import com.facebook.react.bridge.ReadableNativeArray
+import expo.modules.core.interfaces.DoNotStrip
+
+/**
+ * It's a wrapper for a promise-less function that will be invoked from JS.
+ * This interface is intended to be passed to cpp code.
+ * If you want to modify it, please don't forget to change the corresponding jni::JavaClass.
+ */
+@DoNotStrip
+fun interface JNIFunctionBody {
+  /**
+   * Invokes the Kotlin part of the JNI function.
+   *
+   * We used a [com.facebook.react.bridge.ReadableNativeArray] to communicate with CPP, because
+   * right now it's the only object which is recognizable by those two worlds.
+   * In the future, we may want to swap it for something else.
+   */
+  @DoNotStrip
+  fun invoke(args: ReadableNativeArray): ReadableNativeArray?
+}
+
+/**
+ * It's a wrapper for a promise function that will be invoked from JS.
+ * This interface is intended to be passed to cpp code.
+ * If you want to modify it, please don't forget to change the corresponding jni::JavaClass.
+ */
+@DoNotStrip
+fun interface JNIAsyncFunctionBody {
+  /**
+   * Invokes the Kotlin part of the JNI function.
+   *
+   * Note: that the `bridgePromise` has type of [Any], but it should be an instance of [com.facebook.react.bridge.Promise].
+   * This is dictated by the fact that [com.facebook.react.bridge.Promise] isn't a hybrid object of jni::HybridClass.
+   */
+  @DoNotStrip
+  fun invoke(args: ReadableNativeArray, bridgePromise: Any)
+}

package/android/src/main/java/expo/modules/kotlin/jni/JSIInteropModuleRegistry.kt

@@ -0,0 +1,89 @@
+package expo.modules.kotlin.jni
+
+import com.facebook.jni.HybridData
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import expo.modules.core.interfaces.DoNotStrip
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.JavaScriptEvaluateException
+import java.lang.ref.WeakReference
+
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+class JSIInteropModuleRegistry(appContext: AppContext) {
+  private val appContextHolder = WeakReference(appContext)
+
+  // Has to be called "mHybridData" - fbjni uses it via reflection
+  @DoNotStrip
+  private val mHybridData = initHybrid()
+
+  private external fun initHybrid(): HybridData
+
+  /**
+   * Initializes the `ExpoModulesHostObject` and adds it to the global object.
+   */
+  external fun installJSI(
+    jsRuntimePointer: Long,
+    jsInvokerHolder: CallInvokerHolderImpl,
+    nativeInvokerHolder: CallInvokerHolderImpl
+  )
+
+  /**
+   * Initializes the test runtime. Shouldn't be used in the production.
+   */
+  external fun installJSIForTests()
+
+  /**
+   * Evaluates given JavaScript source code.
+   * @throws JavaScriptEvaluateException if the input format is unknown or evaluation causes an error
+   */
+  @Throws(JavaScriptEvaluateException::class)
+  external fun evaluateScript(script: String): JavaScriptValue
+
+  /**
+   * Returns the runtime global object
+   */
+  external fun global(): JavaScriptObject
+
+  /**
+   * Returns a new instance of [JavaScriptObject]
+   */
+  external fun createObject(): JavaScriptObject
+
+  /**
+   * Drains the JavaScript VM internal Microtask (a.k.a. event loop) queue.
+   */
+  external fun drainJSEventLoop()
+
+  /**
+   * Returns a `JavaScriptModuleObject` that is a bridge between [expo.modules.kotlin.modules.Module]
+   * and HostObject exported via JSI.
+   *
+   * This function will be called from the CPP implementation.
+   * It doesn't make sense to call it from Kotlin.
+   */
+  @Suppress("unused")
+  @DoNotStrip
+  fun getJavaScriptModuleObject(name: String): JavaScriptModuleObject? {
+    return appContextHolder.get()?.registry?.getModuleHolder(name)?.jsObject
+  }
+
+  /**
+   * Returns an array that contains names of available modules.
+   */
+  @Suppress("unused")
+  @DoNotStrip
+  fun getJavaScriptModulesName(): Array<String> {
+    return appContextHolder.get()?.registry?.registry?.keys?.toTypedArray() ?: emptyArray()
+  }
+
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    mHybridData.resetNative()
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("expo-modules-core")
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptModuleObject.kt

@@ -0,0 +1,44 @@
+package expo.modules.kotlin.jni
+
+import com.facebook.jni.HybridData
+import com.facebook.react.bridge.NativeMap
+import expo.modules.core.interfaces.DoNotStrip
+
+/**
+ * A class to communicate with CPP part of the [expo.modules.kotlin.modules.Module] class.
+ * Used to register exported JSI functions.
+ * The lifetime of instances of this class should be in sync with the lifetime of the bridge.
+ * All exported functions/objects will have a reference to the `JavaScriptModuleObject`,
+ * so it must outlive the current RN context.
+ */
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+class JavaScriptModuleObject {
+  // Has to be called "mHybridData" - fbjni uses it via reflection
+  @DoNotStrip
+  private val mHybridData = initHybrid()
+
+  private external fun initHybrid(): HybridData
+
+  /**
+   * Exports constants
+   */
+  external fun exportConstants(constants: NativeMap)
+
+  /**
+   * Register a promise-less function on the CPP module representation.
+   * After calling this function, user can access the exported function in the JS code.
+   */
+  external fun registerSyncFunction(name: String, args: Int, body: JNIFunctionBody)
+
+  /**
+   * Register a promise function on the CPP module representation.
+   * After calling this function, user can access the exported function in the JS code.
+   */
+  external fun registerAsyncFunction(name: String, args: Int, body: JNIAsyncFunctionBody)
+
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    mHybridData.resetNative()
+  }
+}