expo-modules-core 0.6.4 → 0.8.0

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

@@ -1,9 +1,13 @@
 package expo.modules.kotlin.modules
 
 import android.os.Bundle
+import expo.modules.core.errors.ModuleDestroyedException
 import expo.modules.kotlin.AppContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
 
 abstract class Module {
+  @Suppress("PropertyName")
   internal var _appContext: AppContext? = null
 
   private val moduleEventEmitter by lazy { appContext.eventEmitter(this) }
@@ -11,14 +15,25 @@ abstract class Module {
   val appContext: AppContext
     get() = requireNotNull(_appContext) { "The module wasn't created! You can't access the app context." }
 
+  @Suppress("PropertyName")
+  @PublishedApi
+  internal lateinit var coroutineScopeDelegate: Lazy<CoroutineScope>
+  val coroutineScope get() = coroutineScopeDelegate.value
+
   fun sendEvent(name: String, body: Bundle?) {
     moduleEventEmitter?.emit(name, body)
   }
 
   abstract fun definition(): ModuleDefinitionData
+
+  internal fun cleanUp() {
+    if (coroutineScopeDelegate.isInitialized()) {
+      coroutineScope.cancel(ModuleDestroyedException())
+    }
+  }
 }
 
 @Suppress("FunctionName")
-inline fun ModuleDefinition(block: ModuleDefinitionBuilder.() -> Unit): ModuleDefinitionData {
-  return ModuleDefinitionBuilder().also(block).build()
+inline fun Module.ModuleDefinition(block: ModuleDefinitionBuilder.() -> Unit): ModuleDefinitionData {
+  return ModuleDefinitionBuilder(this).also(block).build()
 }

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

@@ -23,21 +23,24 @@ 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.methods.AnyMethod
-import expo.modules.kotlin.methods.Method
-import expo.modules.kotlin.methods.PromiseMethod
+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.types.toAnyType
 import expo.modules.kotlin.views.ViewManagerDefinition
 import expo.modules.kotlin.views.ViewManagerDefinitionBuilder
 import kotlin.reflect.typeOf
 
-class ModuleDefinitionBuilder {
+@DefinitionMarker
+class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null) {
   private var name: String? = null
   private var constantsProvider = { emptyMap<String, Any?>() }
   private var eventsDefinition: EventsDefinition? = null
+  private var functionBuilders = mutableListOf<AsyncFunctionBuilder>()
 
   @PublishedApi
-  internal var methods = mutableMapOf<String, AnyMethod>()
+  internal var methods = mutableMapOf<String, AnyFunction>()
 
   @PublishedApi
   internal var viewManagerDefinition: ViewManagerDefinition? = null
@@ -46,127 +49,292 @@ class ModuleDefinitionBuilder {
   internal val eventListeners = mutableMapOf<EventName, EventListener>()
 
   fun build(): ModuleDefinitionData {
+    val moduleName = name ?: module?.javaClass?.simpleName
+
     return ModuleDefinitionData(
-      requireNotNull(name),
+      requireNotNull(moduleName),
       constantsProvider,
-      methods,
+      methods + functionBuilders.associate { it.build() },
       viewManagerDefinition,
       eventListeners,
       eventsDefinition
     )
   }
 
+  /**
+   * Sets the name of the module that is exported to the JavaScript world.
+   */
   fun name(name: String) {
     this.name = name
   }
 
+  /**
+   * Definition function setting the module's constants to export.
+   */
   fun constants(constantsProvider: () -> Map<String, Any?>) {
     this.constantsProvider = constantsProvider
   }
 
-  @JvmName("methodWithoutArgs")
+  /**
+   * Definition of the module's constants to export.
+   */
+  fun constants(vararg constants: Pair<String, Any?>) {
+    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(
     name: String,
     crossinline body: () -> Any?
   ) {
-    methods[name] = Method(name, arrayOf()) { body() }
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
   }
 
+  @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(
     name: String,
     crossinline body: () -> R
   ) {
-    methods[name] = Method(name, arrayOf()) { body() }
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
   }
 
+  @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(
     name: String,
     crossinline body: (p0: P0) -> R
   ) {
     methods[name] = if (P0::class == Promise::class) {
-      PromiseMethod(name, arrayOf()) { _, promise -> body(promise as P0) }
+      AsyncFunctionWithPromise(name, arrayOf()) { _, promise -> body(promise as P0) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
     }
   }
 
+  @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(
     name: String,
     crossinline body: (p0: P0, p1: P1) -> R
   ) {
     methods[name] = if (P1::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+      AsyncFunction(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
     }
   }
 
+  @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(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2) -> R
   ) {
     methods[name] = if (P2::class == Promise::class) {
-      PromiseMethod(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
+      AsyncFunctionWithPromise(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { args, promise -> body(args[0] as P0, args[1] as P1, promise as P2) }
     } else {
-      Method(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }
+      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) }
     }
   }
 
+  @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) {
-      PromiseMethod(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) }
+      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 {
-      Method(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) }
+      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) }
     }
   }
 
+  @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) {
-      PromiseMethod(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) }
+      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 {
-      Method(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) }
+      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) }
     }
   }
 
+  @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(
     name: String,
     crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R
   ) {
     methods[name] = if (P5::class == Promise::class) {
-      PromiseMethod(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) }
+      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 {
-      Method(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) }
+      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) }
     }
   }
 
+  @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) {
-      PromiseMethod(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) }
+      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 {
-      Method(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) }
+      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) }
     }
   }
 
+  @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) {
-      PromiseMethod(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) }
+      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) }
+    }
+  }
+
+  @JvmName("asyncFunctionWithoutArgs")
+  inline fun asyncFunction(
+    name: String,
+    crossinline body: () -> Any?
+  ) {
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+  }
+
+  inline fun <reified R> asyncFunction(
+    name: String,
+    crossinline body: () -> R
+  ) {
+    methods[name] = AsyncFunction(name, arrayOf()) { body() }
+  }
+
+  inline fun <reified R, reified P0> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> asyncFunction(
+    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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> asyncFunction(
+    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 {
-      Method(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) }
+      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) }
     }
   }
 
+  fun asyncFunction(
+    name: String
+  ) = AsyncFunctionBuilder(name).also { functionBuilders.add(it) }
+
+  /**
+   * Creates the view manager definition that scopes other view-related definitions.
+   */
   inline fun viewManager(body: ViewManagerDefinitionBuilder.() -> Unit) {
     require(viewManagerDefinition == null) { "The module definition may have exported only one view manager." }
 
@@ -175,22 +343,37 @@ class ModuleDefinitionBuilder {
     viewManagerDefinition = viewManagerDefinitionBuilder.build()
   }
 
+  /**
+   * Creates module's lifecycle listener that is called right after the module initialization.
+   */
   inline fun onCreate(crossinline body: () -> Unit) {
     eventListeners[EventName.MODULE_CREATE] = BasicEventListener(EventName.MODULE_CREATE) { body() }
   }
 
+  /**
+   * Creates module's lifecycle listener that is called when the module is about to be deallocated.
+   */
   inline fun onDestroy(crossinline body: () -> Unit) {
     eventListeners[EventName.MODULE_DESTROY] = BasicEventListener(EventName.MODULE_DESTROY) { body() }
   }
 
+  /**
+   * Creates module's lifecycle listener that is called right after the activity is resumed.
+   */
   inline fun onActivityEntersForeground(crossinline body: () -> Unit) {
     eventListeners[EventName.ACTIVITY_ENTERS_FOREGROUND] = BasicEventListener(EventName.ACTIVITY_ENTERS_FOREGROUND) { body() }
   }
 
+  /**
+   * Creates module's lifecycle listener that is called right after the activity is paused.
+   */
   inline fun onActivityEntersBackground(crossinline body: () -> Unit) {
     eventListeners[EventName.ACTIVITY_ENTERS_BACKGROUND] = BasicEventListener(EventName.ACTIVITY_ENTERS_BACKGROUND) { body() }
   }
 
+  /**
+   * Creates module's lifecycle listener that is called right after the activity is destroyed.
+   */
   inline fun onActivityDestroys(crossinline body: () -> Unit) {
     eventListeners[EventName.ACTIVITY_DESTROYS] = BasicEventListener(EventName.ACTIVITY_DESTROYS) { body() }
   }
@@ -203,23 +386,29 @@ class ModuleDefinitionBuilder {
   }
 
   /**
-   * Method that is invoked when the first event listener is added.
+   * Creates module's lifecycle listener that is called right after the first event listener is added.
    */
   inline fun onStartObserving(crossinline body: () -> Unit) {
-    function("startObserving", body)
+    asyncFunction("startObserving", body)
   }
 
   /**
-   * Method that is invoked when all event listeners are removed.
+   * Creates module's lifecycle listener that is called right after all event listeners are removed.
    */
   inline fun onStopObserving(crossinline body: () -> Unit) {
-    function("stopObserving", body)
+    asyncFunction("stopObserving", body)
   }
 
+  /**
+   * Creates module's lifecycle listener that is called right after the new intent was received.
+   */
   inline fun onNewIntent(crossinline body: (Intent) -> Unit) {
     eventListeners[EventName.ON_NEW_INTENT] = EventListenerWithPayload<Intent>(EventName.ON_NEW_INTENT) { body(it) }
   }
 
+  /**
+   * Creates module's lifecycle listener that is called right after the activity has received a result.
+   */
   inline fun onActivityResult(crossinline body: (Activity, OnActivityResultPayload) -> Unit) {
     eventListeners[EventName.ON_ACTIVITY_RESULT] =
       EventListenerWithSenderAndPayload<Activity, OnActivityResultPayload>(EventName.ON_ACTIVITY_RESULT) { sender, payload -> body(sender, payload) }

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

@@ -3,13 +3,13 @@ package expo.modules.kotlin.modules
 import expo.modules.kotlin.events.EventListener
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.EventsDefinition
-import expo.modules.kotlin.methods.AnyMethod
+import expo.modules.kotlin.functions.AnyFunction
 import expo.modules.kotlin.views.ViewManagerDefinition
 
 class ModuleDefinitionData(
   val name: String,
   val constantsProvider: () -> Map<String, Any?>,
-  val methods: Map<String, AnyMethod>,
+  val methods: Map<String, AnyFunction>,
   val viewManagerDefinition: ViewManagerDefinition? = null,
   val eventListeners: Map<EventName, EventListener> = emptyMap(),
   val eventsDefinition: EventsDefinition? = null

package/android/src/main/java/expo/modules/kotlin/records/FieldValidator.kt

@@ -0,0 +1,139 @@
+package expo.modules.kotlin.records
+
+import expo.modules.kotlin.exception.ValidationException
+
+interface FieldValidator<T> {
+  fun validate(value: T)
+}
+
+class NumericRangeValidator<T : Comparable<T>>(
+  private val from: T,
+  private val to: T,
+  private val fromInclusive: Boolean,
+  private val toInclusive: Boolean
+) : FieldValidator<T> {
+  override fun validate(value: T) {
+    if (
+      value < from ||
+      to < value ||
+      value == from && !fromInclusive ||
+      value == to && !toInclusive
+    ) {
+      throw ValidationException("Value should be in range $from ${if (fromInclusive) "<=" else "<"} 'value' ${if (toInclusive) "<=" else "<"} $to, got $value")
+    }
+  }
+}
+
+class IsNotEmptyCollectionValidator : FieldValidator<Collection<*>> {
+  override fun validate(value: Collection<*>) {
+    if (value.isEmpty()) {
+      throw ValidationException("Collection is empty")
+    }
+  }
+}
+
+class IsNotEmptyIntArrayValidator : FieldValidator<IntArray> {
+  override fun validate(value: IntArray) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class IsNotEmptyFloatArrayValidator : FieldValidator<FloatArray> {
+  override fun validate(value: FloatArray) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class IsNotEmptyDoubleArrayValidator : FieldValidator<DoubleArray> {
+  override fun validate(value: DoubleArray) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class IsNotEmptyArrayValidator : FieldValidator<Array<*>> {
+  override fun validate(value: Array<*>) {
+    if (value.isEmpty()) {
+      throw ValidationException("Array is empty")
+    }
+  }
+}
+
+class CollectionSizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<Collection<*>> {
+  override fun validate(value: Collection<*>) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the collection should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class IntArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<IntArray> {
+  override fun validate(value: IntArray) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class DoubleArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<DoubleArray> {
+  override fun validate(value: DoubleArray) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class FloatArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<FloatArray> {
+  override fun validate(value: FloatArray) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class ArraySizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<Array<*>> {
+  override fun validate(value: Array<*>) {
+    if (value.size < min || value.size > max) {
+      throw ValidationException("Number of elements in the array should be between $min and $max, got ${value.size}")
+    }
+  }
+}
+
+class StringSizeValidator(
+  private val min: Int,
+  private val max: Int
+) : FieldValidator<String> {
+  override fun validate(value: String) {
+    if (value.length < min || value.length > max) {
+      throw ValidationException("Length of the string should be between $min and $max, got $value (${value.length} characters)")
+    }
+  }
+}
+
+class RegexValidator(private val regex: Regex) : FieldValidator<CharSequence> {
+  override fun validate(value: CharSequence) {
+    if (!regex.matches(value)) {
+      throw ValidationException("Provided string $value didn't match regex $regex")
+    }
+  }
+}