expo-modules-core 0.9.2 → 0.11.1

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

@@ -6,159 +6,51 @@ 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
-
-  @Deprecated(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("SuspendBody(block)")
-  )
-  inline fun <reified R> suspendBody(crossinline block: suspend () -> R) = SuspendBody(block)
+  internal var functionBuilder: SuspendFunctionComponentBuilder? = null
 
   inline fun <reified R> SuspendBody(crossinline block: suspend () -> R) {
-    function = AsyncSuspendFunction(name, arrayOf()) { block() }
+    functionBuilder = SuspendFunctionComponentBuilder(name, arrayOf()) { block() }
   }
 
-  @Deprecated(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("SuspendBody(block)")
-  )
-  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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("SuspendBody(block)")
-  )
-  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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("SuspendBody(block)")
-  )
-  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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("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) = 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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("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) = 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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("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) = 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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("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) = 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(
-    message = "The 'suspendBody' component was renamed to 'SuspendBody'.",
-    replaceWith = ReplaceWith("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) = 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)
   }
 }
 
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R> AsyncFunctionBuilder.coroutine(crossinline block: suspend () -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1, reified P2> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6) -> R) = Coroutine(block)
-
-@Deprecated(
-  message = "The 'coroutine' component was renamed to 'Coroutine'.",
-  replaceWith = ReplaceWith("Coroutine(block)")
-)
-inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6, P7) -> R) = Coroutine(block)
-
 inline infix fun <reified R> AsyncFunctionBuilder.Coroutine(crossinline block: suspend () -> R) = SuspendBody(block)
 inline infix fun <reified R, reified P0> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0) -> R) = SuspendBody(block)
 inline infix fun <reified R, reified P0, reified P1> AsyncFunctionBuilder.Coroutine(crossinline block: suspend (P0, P1) -> R) = SuspendBody(block)

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

@@ -0,0 +1,21 @@
+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) {
+    promise.resolve(body(convertArgs(args)))
+  }
+
+  override fun call(args: Array<Any?>, promise: Promise) {
+    promise.resolve(body(convertArgs(args)))
+  }
+}

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

@@ -0,0 +1,21 @@
+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) {
+    body(convertArgs(args), promise)
+  }
+
+  override fun call(args: Array<Any?>, promise: Promise) {
+    body(convertArgs(args), promise)
+  }
+}

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

@@ -0,0 +1,63 @@
+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
+
+/**
+ * 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) {
+    callWithConvertedArguments(convertArgs(args), promise)
+  }
+
+  override fun call(args: Array<Any?>, promise: Promise) {
+    callWithConvertedArguments(convertArgs(args), promise)
+  }
+
+  private fun callWithConvertedArguments(convertedArgs: Array<out Any?>, promise: Promise) {
+    val holder = moduleHolderRef.get() ?: return
+    val scope = holder.module.coroutineScopeDelegate.value
+
+    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,36 @@
+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))
+  }
+
+  fun call(args: Array<Any?>): Any? {
+    return body(convertArgs(args))
+  }
+
+  override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
+    jsObject.registerSyncFunction(
+      name,
+      argsCount,
+      getCppRequiredTypes()
+    ) { 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,19 @@
+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) {
+  NONE(0),
+  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: Array<Any?>): 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: Array<Any?>, 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,46 @@
+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, desiredTypes: IntArray, 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, desiredTypes: IntArray, body: JNIAsyncFunctionBody)
+
+  external fun registerProperty(name: String, desiredType: Int, getter: JNIFunctionBody?, setter: JNIFunctionBody?)
+
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    mHybridData.resetNative()
+  }
+}

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

@@ -0,0 +1,113 @@
+package expo.modules.kotlin.jni
+
+import com.facebook.jni.HybridData
+import expo.modules.core.interfaces.DoNotStrip
+
+/**
+ * A Kotlin representation of jsi::Object.
+ * Should be used only on the runtime thread.
+ */
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+class JavaScriptObject @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) {
+  /**
+   * The property descriptor options for the property being defined or modified.
+   */
+  enum class PropertyDescriptor(val value: Int) {
+    /**
+     * If set, the type of this property descriptor may be changed and if the property may be deleted from the corresponding object.
+     */
+    Configurable(1 shl 0),
+
+    /**
+     * If set, the property shows up during enumeration of the properties on the corresponding object.
+     */
+    Enumerable(1 shl 1),
+
+    /**
+     * If set, the value associated with the property may be changed with an assignment operator.
+     */
+    Writable(1 shl 2),
+  }
+
+  external fun hasProperty(name: String): Boolean
+  external fun getProperty(name: String): JavaScriptValue
+  external fun getPropertyNames(): Array<String>
+
+  private external fun setBoolProperty(name: String, value: Boolean)
+  private external fun setDoubleProperty(name: String, value: Double)
+  private external fun setStringProperty(name: String, value: String?)
+  private external fun setJSValueProperty(name: String, value: JavaScriptValue?)
+  private external fun setJSObjectProperty(name: String, value: JavaScriptObject?)
+  private external fun unsetProperty(name: String)
+
+  private external fun defineBoolProperty(name: String, value: Boolean, options: Int)
+  private external fun defineDoubleProperty(name: String, value: Double, options: Int)
+  private external fun defineStringProperty(name: String, value: String?, options: Int)
+  private external fun defineJSValueProperty(name: String, value: JavaScriptValue?, options: Int)
+  private external fun defineJSObjectProperty(name: String, value: JavaScriptObject?, options: Int)
+
+  fun setProperty(name: String, value: Boolean) = setBoolProperty(name, value)
+  fun setProperty(name: String, value: Int) = setDoubleProperty(name, value.toDouble())
+  fun setProperty(name: String, value: Double) = setDoubleProperty(name, value)
+  fun setProperty(name: String, value: String?) = setStringProperty(name, value)
+  fun setProperty(name: String, value: JavaScriptValue?) = setJSValueProperty(name, value)
+  fun setProperty(name: String, value: JavaScriptObject?) = setJSObjectProperty(name, value)
+
+  // Needed to handle untyped null value
+  // Without it setProperty(name, null) won't work
+  fun setProperty(name: String, `null`: Nothing?) = unsetProperty(name)
+
+  fun defineProperty(
+    name: String,
+    value: Boolean,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineBoolProperty(name, value, options.toCppOptions())
+
+  fun defineProperty(
+    name: String,
+    value: Int,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineDoubleProperty(name, value.toDouble(), options.toCppOptions())
+
+  fun defineProperty(
+    name: String,
+    value: Double,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineDoubleProperty(name, value, options.toCppOptions())
+
+  fun defineProperty(
+    name: String,
+    value: String?,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineStringProperty(name, value, options.toCppOptions())
+
+  fun defineProperty(
+    name: String,
+    value: JavaScriptValue?,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineJSValueProperty(name, value, options.toCppOptions())
+
+  fun defineProperty(
+    name: String,
+    value: JavaScriptObject?,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineJSObjectProperty(name, value, options.toCppOptions())
+
+  // Needed to handle untyped null value
+  fun defineProperty(
+    name: String,
+    `null`: Nothing?,
+    options: List<PropertyDescriptor> = emptyList()
+  ) = defineJSObjectProperty(name, null, options.toCppOptions())
+
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    mHybridData.resetNative()
+  }
+}
+
+private fun List<JavaScriptObject.PropertyDescriptor>.toCppOptions(): Int =
+  fold(0) { acc, current ->
+    acc or current.value
+  }

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

@@ -0,0 +1,35 @@
+package expo.modules.kotlin.jni
+
+import com.facebook.jni.HybridData
+import expo.modules.core.interfaces.DoNotStrip
+
+/**
+ * A Kotlin representation of jsi::Value.
+ * Should be used only on the runtime thread.
+ */
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) {
+  external fun kind(): String
+
+  external fun isNull(): Boolean
+  external fun isUndefined(): Boolean
+  external fun isBool(): Boolean
+  external fun isNumber(): Boolean
+  external fun isString(): Boolean
+  external fun isSymbol(): Boolean
+  external fun isFunction(): Boolean
+  external fun isArray(): Boolean
+  external fun isObject(): Boolean
+
+  external fun getBool(): Boolean
+  external fun getDouble(): Double
+  external fun getString(): String
+  external fun getObject(): JavaScriptObject
+  external fun getArray(): Array<JavaScriptValue>
+
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    mHybridData.resetNative()
+  }
+}