expo-modules-core 0.9.0 → 0.10.0

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()
+  }
+}

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

@@ -3,24 +3,34 @@ package expo.modules.kotlin.modules
 import android.os.Bundle
 import expo.modules.core.errors.ModuleDestroyedException
 import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.providers.AppContextProvider
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.cancel
 
-abstract class Module {
+abstract class Module : AppContextProvider {
+
+  // region AppContextProvider
+
   @Suppress("PropertyName")
   internal var _appContext: AppContext? = null
 
-  private val moduleEventEmitter by lazy { appContext.eventEmitter(this) }
-
-  val appContext: AppContext
+  override val appContext: AppContext
     get() = requireNotNull(_appContext) { "The module wasn't created! You can't access the app context." }
 
+  // endregion
+
+  private val moduleEventEmitter by lazy { appContext.eventEmitter(this) }
+
   @Suppress("PropertyName")
   @PublishedApi
   internal lateinit var coroutineScopeDelegate: Lazy<CoroutineScope>
   val coroutineScope get() = coroutineScopeDelegate.value
 
-  fun sendEvent(name: String, body: Bundle?) {
+  fun sendEvent(name: String, body: Bundle? = Bundle.EMPTY) {
+    moduleEventEmitter?.emit(name, body)
+  }
+
+  fun sendEvent(name: String, body: Map<String, Any?>?) {
     moduleEventEmitter?.emit(name, body)
   }
 

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

@@ -24,10 +24,11 @@ import expo.modules.kotlin.events.EventListenerWithSenderAndPayload
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.EventsDefinition
 import expo.modules.kotlin.events.OnActivityResultPayload
-import expo.modules.kotlin.functions.AnyFunction
 import expo.modules.kotlin.functions.AsyncFunction
-import expo.modules.kotlin.functions.AsyncFunctionWithPromise
 import expo.modules.kotlin.functions.AsyncFunctionBuilder
+import expo.modules.kotlin.functions.AsyncFunctionComponent
+import expo.modules.kotlin.functions.AsyncFunctionWithPromiseComponent
+import expo.modules.kotlin.functions.SyncFunctionComponent
 import expo.modules.kotlin.types.toAnyType
 import expo.modules.kotlin.views.ViewManagerDefinition
 import expo.modules.kotlin.views.ViewManagerDefinitionBuilder
@@ -41,7 +42,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
   private var functionBuilders = mutableListOf<AsyncFunctionBuilder>()
 
   @PublishedApi
-  internal var methods = mutableMapOf<String, AnyFunction>()
+  internal var syncFunctions = mutableMapOf<String, SyncFunctionComponent>()
+
+  @PublishedApi
+  internal var asyncFunctions = mutableMapOf<String, AsyncFunction>()
 
   @PublishedApi
   internal var viewManagerDefinition: ViewManagerDefinition? = null
@@ -55,7 +59,9 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     return ModuleDefinitionData(
       requireNotNull(moduleName),
       constantsProvider,
-      methods + functionBuilders.associate { it.build() },
+      syncFunctions,
+      asyncFunctions,
+      functionBuilders.map { it.build() },
       viewManagerDefinition,
       eventListeners,
       eventsDefinition
@@ -101,146 +107,94 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     constantsProvider = { constants.toMap() }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
-  @JvmName("functionWithoutArgs")
-  inline fun function(
+  @JvmName("FunctionWithoutArgs")
+  inline fun Function(
     name: String,
     crossinline body: () -> Any?
   ) {
-    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+    SyncFunctionComponent(name, arrayOf()) { body() }.also {
+      syncFunctions[name] = it
+    }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
-  inline fun <reified R> function(
+  inline fun <reified R> Function(
     name: String,
     crossinline body: () -> R
   ) {
-    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+    SyncFunctionComponent(name, arrayOf()) { body() }.also {
+      syncFunctions[name] = it
+    }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
-  inline fun <reified R, reified P0> function(
+  inline fun <reified R, reified P0> Function(
     name: String,
     crossinline body: (p0: P0) -> R
   ) {
-    methods[name] = if (P0::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf()) { _, promise -> body(promise as P0) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
-  inline fun <reified R, reified P0, reified P1> function(
+  inline fun <reified R, reified P0, reified P1> Function(
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ) {
-    methods[name] = if (P1::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
-  inline fun <reified R, reified P0, reified P1, reified P2> function(
+  inline fun <reified R, reified P0, reified P1, reified P2> Function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ) {
-    methods[name] = if (P2::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ) {
-    methods[name] = if (P3::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ) {
-    methods[name] = if (P4::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
-  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> function(
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> Function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ) {
-    methods[name] = if (P5::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ) {
-    methods[name] = if (P6::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(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) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(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) }.also {
+      syncFunctions[name] = it
     }
   }
 
-  @Deprecated(
-    message = "The 'function' component was deprecated and will change its behavior in the future.",
-    replaceWith = ReplaceWith("AsyncFunction(name, body)")
-  )
   inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> function(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ) {
-    methods[name] = if (P7::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
-    } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(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) }
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(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) }.also {
+      syncFunctions[name] = it
     }
   }
 
@@ -259,7 +213,7 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: () -> Any?
   ) {
-    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+    asyncFunctions[name] = AsyncFunctionComponent(name, arrayOf()) { body() }
   }
 
   @Deprecated(
@@ -275,7 +229,7 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: () -> R
   ) {
-    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+    asyncFunctions[name] = AsyncFunctionComponent(name, arrayOf()) { body() }
   }
 
   @Deprecated(
@@ -291,10 +245,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0) -> R
   ) {
-    methods[name] = if (P0::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf()) { _, promise -> body(promise as P0) }
+    asyncFunctions[name] = if (P0::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf()) { _, promise -> body(promise as P0) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
     }
   }
 
@@ -311,10 +265,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ) {
-    methods[name] = if (P1::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+    asyncFunctions[name] = if (P1::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
     }
   }
 
@@ -331,10 +285,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ) {
-    methods[name] = if (P2::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
+    asyncFunctions[name] = if (P2::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
     }
   }
 
@@ -351,10 +305,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> R
   ) {
-    methods[name] = if (P3::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
+    asyncFunctions[name] = if (P3::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, promise as P3) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3) }
     }
   }
 
@@ -371,10 +325,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R
   ) {
-    methods[name] = if (P4::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
+    asyncFunctions[name] = if (P4::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, promise as P4) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4) }
     }
   }
 
@@ -391,10 +345,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ) {
-    methods[name] = if (P5::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
+    asyncFunctions[name] = if (P5::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, promise as P5) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2, it[3] as P3, it[4] as P4, it[5] as P5) }
     }
   }
 
@@ -411,10 +365,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R
   ) {
-    methods[name] = if (P6::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
+    asyncFunctions[name] = if (P6::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, promise as P6) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(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) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { body(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) }
     }
   }
 
@@ -431,10 +385,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R
   ) {
-    methods[name] = if (P7::class == Promise::class) {
-      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
+    asyncFunctions[name] = if (P7::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, args[2] as P2, args[3] as P3, args[4] as P4, args[5] as P5, args[6] as P6, promise as P7) }
     } else {
-      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(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) }
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType(), typeOf<P3>().toAnyType(), typeOf<P4>().toAnyType(), typeOf<P5>().toAnyType(), typeOf<P6>().toAnyType(), typeOf<P7>().toAnyType())) { body(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) }
     }
   }
 

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

@@ -1,16 +1,49 @@
 package expo.modules.kotlin.modules
 
+import expo.modules.kotlin.ConcatIterator
+import expo.modules.kotlin.ModuleHolder
 import expo.modules.kotlin.events.EventListener
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.EventsDefinition
-import expo.modules.kotlin.functions.AnyFunction
+import expo.modules.kotlin.functions.AsyncFunction
+import expo.modules.kotlin.functions.SuspendFunctionComponentBuilder
+import expo.modules.kotlin.functions.SyncFunctionComponent
 import expo.modules.kotlin.views.ViewManagerDefinition
 
+/**
+ * Intermediate data used to create a proper [ProcessedModuleDefinition].
+ * It contains all, unprocessed data from [ModuleDefinitionBuilder].
+ */
 class ModuleDefinitionData(
   val name: String,
   val constantsProvider: () -> Map<String, Any?>,
-  val methods: Map<String, AnyFunction>,
+  val syncFunctions: Map<String, SyncFunctionComponent>,
+  val asyncFunctions: Map<String, AsyncFunction>,
+  val suspendFunctionBuilders: List<SuspendFunctionComponentBuilder>,
   val viewManagerDefinition: ViewManagerDefinition? = null,
   val eventListeners: Map<EventName, EventListener> = emptyMap(),
   val eventsDefinition: EventsDefinition? = null
 )
+
+/**
+ * A final version of the ModuleDefinition.
+ * Most values are just copied from [ModuleDefinitionData].
+ * However some fields like `asyncFunctions` need to be processed or bound with the [ModuleHolder].
+ */
+class ProcessedModuleDefinition(
+  data: ModuleDefinitionData,
+  moduleHolder: ModuleHolder
+) {
+  val name = data.name
+  val constantsProvider = data.constantsProvider
+  val syncFunctions = data.syncFunctions
+  val asyncFunctions = data.asyncFunctions + data.suspendFunctionBuilders.associate { builder ->
+    builder.name to builder.build((moduleHolder))
+  }
+  val viewManagerDefinition = data.viewManagerDefinition
+  val eventListeners = data.eventListeners
+  val eventsDefinition = data.eventsDefinition
+
+  val functions
+    get() = ConcatIterator(syncFunctions.values.iterator(), asyncFunctions.values.iterator())
+}

package/android/src/main/java/expo/modules/kotlin/providers/AppContextProvider.kt

@@ -0,0 +1,14 @@
+package expo.modules.kotlin.providers
+
+import expo.modules.kotlin.AppContext
+
+/**
+ * Provider that allows accessing [AppContext] and all it's public parts (e.g. [AppContext.reactContext]).
+ */
+interface AppContextProvider {
+  /**
+   * [AppContext] reference. If it's not possible to access the [AppContext], because it's null
+   * then it's an invalid situation and should result in throwing descriptive error.
+   */
+  val appContext: AppContext
+}

package/android/src/main/java/expo/modules/kotlin/providers/CurrentActivityProvider.kt

@@ -0,0 +1,22 @@
+package expo.modules.kotlin.providers
+
+import com.facebook.react.ReactActivity
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.FragmentActivity
+import androidx.core.app.ComponentActivity
+import android.app.Activity
+
+/**
+ * A class that provides the accessor to the [ReactActivity]. It enables accessing
+ * AndroidX/Android Jetpack features in Expo libraries coming from all subclassing chain:
+ * [AppCompatActivity], [FragmentActivity], [ComponentActivity], [Activity]
+*/
+interface CurrentActivityProvider {
+  /**
+   * Returns the current [Activity] that should be an instance of [AppCompatActivity].
+   * This activity is most likely an instance of [ReactActivity], but it's been decided not to expose
+   * `react-native` symbols via `expo-module-core` public API.
+   * @returns null if the [Activity] is not yet available (eg. Application has not yet fully started)
+   */
+  val currentActivity: AppCompatActivity?
+}