expo-modules-core 0.7.0 → 0.8.0

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

@@ -23,22 +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
 
 @DefinitionMarker
-class ModuleDefinitionBuilder(private val module: Module? = null) {
+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
@@ -52,7 +54,7 @@ class ModuleDefinitionBuilder(private val module: Module? = null) {
     return ModuleDefinitionData(
       requireNotNull(moduleName),
       constantsProvider,
-      methods,
+      methods + functionBuilders.associate { it.build() },
       viewManagerDefinition,
       eventListeners,
       eventsDefinition
@@ -80,109 +82,256 @@ class ModuleDefinitionBuilder(private val module: Module? = null) {
     constantsProvider = { constants.toMap() }
   }
 
-  @JvmName("methodWithoutArgs")
+  @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 {
-      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) }
     }
   }
 
+  @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 {
+      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.
    */
@@ -240,14 +389,14 @@ class ModuleDefinitionBuilder(private val module: Module? = null) {
    * 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)
   }
 
   /**
    * 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)
   }
 
   /**

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

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

@@ -1,42 +1,3 @@
 package expo.modules.kotlin.records
 
-import android.os.Bundle
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
-import java.lang.IllegalArgumentException
-import kotlin.reflect.full.findAnnotation
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.isAccessible
-
 interface Record
-
-fun Record.toJSMap(): ReadableMap {
-  val writableMap = Arguments.createMap()
-  javaClass
-    .kotlin
-    .memberProperties.map { property ->
-      val fieldInformation = property.findAnnotation<Field>() ?: return@map
-      val jsKey = fieldInformation.key.takeUnless { it == "" } ?: property.name
-
-      property.isAccessible = true
-
-      // TODO(@lukmccall): add more sophisticated conversion method
-      when (val value = property.get(this)) {
-        null, is Unit -> writableMap.putNull(jsKey)
-        is Boolean -> writableMap.putBoolean(jsKey, value)
-        is Int -> writableMap.putInt(jsKey, value)
-        is Number -> writableMap.putDouble(jsKey, value.toDouble())
-        is String -> writableMap.putString(jsKey, value)
-        is ReadableArray -> writableMap.putArray(jsKey, value)
-        is ReadableMap -> writableMap.putMap(jsKey, value)
-        is Record -> writableMap.putMap(jsKey, value.toJSMap())
-        is Bundle -> writableMap.putMap(jsKey, Arguments.fromBundle(value))
-        is List<*> -> writableMap.putArray(jsKey, Arguments.fromList(value))
-        is Array<*> -> writableMap.putArray(jsKey, Arguments.fromArray(value))
-        else -> throw IllegalArgumentException("Could not convert " + value.javaClass)
-      }
-    }
-
-  return writableMap
-}

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

@@ -4,23 +4,41 @@ import com.facebook.react.bridge.Dynamic
 import expo.modules.kotlin.allocators.ObjectConstructor
 import expo.modules.kotlin.allocators.ObjectConstructorFactory
 import expo.modules.kotlin.exception.FieldCastException
+import expo.modules.kotlin.exception.FieldRequiredException
 import expo.modules.kotlin.exception.RecordCastException
 import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.TypeConverter
 import expo.modules.kotlin.types.TypeConverterProvider
 import kotlin.reflect.KClass
+import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
+import kotlin.reflect.full.createInstance
 import kotlin.reflect.full.findAnnotation
 import kotlin.reflect.full.memberProperties
 import kotlin.reflect.jvm.javaField
 
-// TODO(@lukmccall): create all converters during initialization
 class RecordTypeConverter<T : Record>(
   private val converterProvider: TypeConverterProvider,
   val type: KType,
 ) : TypeConverter<T>(type.isMarkedNullable) {
   private val objectConstructorFactory = ObjectConstructorFactory()
+  private val propertyDescriptors: Map<KProperty1<out Any, *>, PropertyDescriptor> =
+    (type.classifier as KClass<*>)
+      .memberProperties
+      .map { property ->
+        val fieldAnnotation = property.findAnnotation<Field>() ?: return@map null
+        val typeConverter = converterProvider.obtainTypeConverter(property.returnType)
+
+        return@map property to PropertyDescriptor(
+          typeConverter,
+          fieldAnnotation,
+          isRequired = property.findAnnotation<Required>() != null,
+          validators = getValidators(property)
+        )
+      }
+      .filterNotNull()
+      .toMap()
 
   override fun convertNonOptional(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
     val jsMap = value.asMap()
@@ -28,23 +46,32 @@ class RecordTypeConverter<T : Record>(
     val kClass = type.classifier as KClass<*>
     val instance = getObjectConstructor(kClass.java).construct()
 
-    kClass
-      .memberProperties
-      .map { property ->
-        val filedInformation = property.findAnnotation<Field>() ?: return@map
-        val jsKey = filedInformation.key.takeUnless { it == "" } ?: property.name
+    propertyDescriptors
+      .forEach { (property, descriptor) ->
+        val jsKey = descriptor.fieldAnnotation.key.takeUnless { it.isBlank() } ?: property.name
 
         if (!jsMap.hasKey(jsKey)) {
-          // TODO(@lukmccall): handle required keys
-          return@map
+          if (descriptor.isRequired) {
+            throw FieldRequiredException(property)
+          }
+
+          return@forEach
         }
 
         jsMap.getDynamic(jsKey).recycle {
           val javaField = property.javaField!!
 
-          val elementConverter = converterProvider.obtainTypeConverter(property.returnType)
           val casted = exceptionDecorator({ cause -> FieldCastException(property.name, property.returnType, type, cause) }) {
-            elementConverter.convert(this)
+            descriptor.typeConverter.convert(this)
+          }
+
+          if (casted != null) {
+            descriptor
+              .validators
+              .forEach { validator ->
+                @Suppress("UNCHECKED_CAST")
+                (validator as FieldValidator<Any>).validate(casted)
+              }
           }
 
           javaField.isAccessible = true
@@ -59,4 +86,26 @@ class RecordTypeConverter<T : Record>(
   private fun <T> getObjectConstructor(clazz: Class<T>): ObjectConstructor<T> {
     return objectConstructorFactory.get(clazz)
   }
+
+  private fun getValidators(property: KProperty1<out Any, *>): List<FieldValidator<*>> {
+    return property
+      .annotations
+      .map findValidators@{ annotation ->
+        val binderAnnotation = annotation.annotationClass.findAnnotation<BindUsing>()
+          ?: return@findValidators null
+        annotation to binderAnnotation
+      }
+      .filterNotNull()
+      .map { (annotation, binderAnnotation) ->
+        val binderInstance = binderAnnotation.binder.createInstance() as ValidationBinder
+        binderInstance.bind(annotation, property.returnType)
+      }
+  }
+
+  private data class PropertyDescriptor(
+    val typeConverter: TypeConverter<*>,
+    val fieldAnnotation: Field,
+    val isRequired: Boolean,
+    val validators: List<FieldValidator<*>>
+  )
 }

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

@@ -0,0 +1,5 @@
+package expo.modules.kotlin.records
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Required