expo-modules-core 1.2.6 → 1.3.0

package/android/src/main/java/expo/modules/kotlin/types/TypeConverterProvider.kt

@@ -4,17 +4,22 @@ package expo.modules.kotlin.types
 
 import android.graphics.Color
 import android.net.Uri
+import android.view.View
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import expo.modules.annotation.Config
 import expo.modules.kotlin.apifeatures.EitherType
 import expo.modules.kotlin.exception.MissingTypeConverter
 import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.jni.ExpectedType
+import expo.modules.kotlin.jni.JavaScriptFunction
 import expo.modules.kotlin.jni.JavaScriptObject
 import expo.modules.kotlin.jni.JavaScriptValue
 import expo.modules.kotlin.records.Record
 import expo.modules.kotlin.records.RecordTypeConverter
+import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.kotlin.sharedobjects.SharedObjectTypeConverter
 import expo.modules.kotlin.typedarray.BigInt64Array
 import expo.modules.kotlin.typedarray.BigUint64Array
 import expo.modules.kotlin.typedarray.Float32Array
@@ -32,6 +37,7 @@ import expo.modules.kotlin.types.io.PathTypeConverter
 import expo.modules.kotlin.types.net.JavaURITypeConverter
 import expo.modules.kotlin.types.net.URLTypConverter
 import expo.modules.kotlin.types.net.UriTypeConverter
+import expo.modules.kotlin.views.ViewTypeConverter
 import java.io.File
 import java.net.URI
 import java.net.URL
@@ -69,6 +75,7 @@ fun convert(value: Dynamic, type: KType): Any? {
 object TypeConverterProviderImpl : TypeConverterProvider {
   private val cachedConverters = createCashedConverters(false) + createCashedConverters(true)
   private val cachedRecordConverters = mutableMapOf<KClass<*>, TypeConverter<*>>()
+  private val cachedCustomConverters = mutableMapOf<KType, TypeConverter<*>>()
 
   override fun obtainTypeConverter(type: KType): TypeConverter<*> {
     cachedConverters[type]?.let {
@@ -113,7 +120,21 @@ object TypeConverterProviderImpl : TypeConverterProvider {
       return converter
     }
 
-    return handelEither(type, kClass) ?: throw MissingTypeConverter(type)
+    if (kClass.isSubclassOf(View::class)) {
+      return ViewTypeConverter<View>(type)
+    }
+
+    if (kClass.isSubclassOf(SharedObject::class)) {
+      return SharedObjectTypeConverter<SharedObject>(type)
+    }
+
+    if (kClass.isSubclassOf(JavaScriptFunction::class)) {
+      return JavaScriptFunctionTypeConverter<Any>(type)
+    }
+
+    return handelEither(type, kClass)
+      ?: handelCustomConverter(type, kClass)
+      ?: throw MissingTypeConverter(type)
   }
 
   @OptIn(EitherType::class)
@@ -131,6 +152,29 @@ object TypeConverterProviderImpl : TypeConverterProvider {
     return null
   }
 
+  private fun handelCustomConverter(type: KType, kClass: KClass<*>): TypeConverter<*>? {
+    val cachedConverter = cachedCustomConverters[type]
+    if (cachedConverter != null) {
+      return cachedConverter
+    }
+
+    val typeName = kClass.java.canonicalName ?: return null
+
+    val converterProviderName = "${Config.packageNamePrefix}$typeName${Config.classNameSuffix}"
+    return try {
+      val converterClazz = Class.forName(converterProviderName)
+      val converterProvider = converterClazz.newInstance()
+      val method = converterProvider.javaClass.getMethod(Config.converterProviderFunctionName, KType::class.java)
+
+      (method.invoke(converterProvider, type) as TypeConverter<*>)
+        .also {
+          cachedCustomConverters[type] = it
+        }
+    } catch (e: Throwable) {
+      null
+    }
+  }
+
   private fun createCashedConverters(isOptional: Boolean): Map<KType, TypeConverter<*>> {
     val intTypeConverter = createTrivialTypeConverter(
       isOptional, ExpectedType(CppType.INT)

package/android/src/main/java/expo/modules/kotlin/types/TypedArrayTypeConverter.kt

@@ -1,5 +1,6 @@
 package expo.modules.kotlin.types
 
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.jni.ExpectedType
 import expo.modules.kotlin.jni.JavaScriptTypedArray
@@ -16,8 +17,8 @@ import expo.modules.kotlin.typedarray.Uint32Array
 import expo.modules.kotlin.typedarray.Uint8Array
 import expo.modules.kotlin.typedarray.Uint8ClampedArray
 
-abstract class BaseTypeArrayConverter<T : TypedArray>(isOptional: Boolean) : TypeConverter<T>(isOptional) {
-  override fun convertNonOptional(value: Any): T = wrapJavaScriptTypedArray(value as JavaScriptTypedArray)
+abstract class BaseTypeArrayConverter<T : TypedArray>(isOptional: Boolean) : NullAwareTypeConverter<T>(isOptional) {
+  override fun convertNonOptional(value: Any, context: AppContext?): T = wrapJavaScriptTypedArray(value as JavaScriptTypedArray)
   override fun getCppRequiredTypes(): ExpectedType = ExpectedType(CppType.TYPED_ARRAY)
   override fun isTrivial() = false
 

package/android/src/main/java/expo/modules/kotlin/views/AnyViewProp.kt

@@ -2,9 +2,11 @@ package expo.modules.kotlin.views
 
 import android.view.View
 import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.types.AnyType
 
 abstract class AnyViewProp(
-  val name: String
+  val name: String,
+  internal val type: AnyType
 ) {
   abstract fun set(prop: Dynamic, onView: View)
 

package/android/src/main/java/expo/modules/kotlin/views/ConcreteViewProp.kt

@@ -8,16 +8,16 @@ import expo.modules.kotlin.types.AnyType
 
 class ConcreteViewProp<ViewType : View, PropType>(
   name: String,
-  private val propType: AnyType,
+  propType: AnyType,
   private val setter: (view: ViewType, prop: PropType) -> Unit,
-) : AnyViewProp(name) {
+) : AnyViewProp(name, propType) {
 
   @Suppress("UNCHECKED_CAST")
   override fun set(prop: Dynamic, onView: View) {
     exceptionDecorator({
       PropSetException(name, onView::class, it)
     }) {
-      setter(onView as ViewType, propType.convert(prop) as PropType)
+      setter(onView as ViewType, type.convert(prop) as PropType)
     }
   }
 

package/android/src/main/java/expo/modules/kotlin/views/FilteredReadableMap.kt

@@ -0,0 +1,53 @@
+package expo.modules.kotlin.views
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableMapKeySetIterator
+import expo.modules.kotlin.Filter
+import expo.modules.kotlin.FilteredIterator
+
+class FilteredReadableMapKeySetIterator(
+  private val iterator: ReadableMapKeySetIterator,
+  private val filter: Filter<String>
+) : ReadableMapKeySetIterator {
+  private var next: String? = null
+
+  init {
+    this.findNext()
+  }
+
+  override fun hasNextKey(): Boolean {
+    return next != null
+  }
+
+  override fun nextKey(): String {
+    val returnValue = next!!
+    this.findNext()
+    return returnValue
+  }
+
+  private fun findNext() {
+    while (iterator.hasNextKey()) {
+      val next = iterator.nextKey()
+      this.next = next
+      if (filter.apply(next)) {
+        return
+      }
+    }
+    next = null
+  }
+}
+
+class FilteredReadableMap(
+  private val backingMap: ReadableMap,
+  private val filteredKeys: List<String>
+) : ReadableMap by backingMap {
+  override fun getEntryIterator(): Iterator<Map.Entry<String, Any>> =
+    FilteredIterator(backingMap.entryIterator) {
+      !filteredKeys.contains(it.key)
+    }
+
+  override fun keySetIterator(): ReadableMapKeySetIterator =
+    FilteredReadableMapKeySetIterator(backingMap.keySetIterator()) {
+      !filteredKeys.contains(it)
+    }
+}

package/android/src/main/java/expo/modules/kotlin/views/GroupViewManagerWrapper.kt

@@ -2,11 +2,11 @@ package expo.modules.kotlin.views
 
 import android.view.View
 import android.view.ViewGroup
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ReactStylesDiffMap
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
-import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.getBackingMap
 import expo.modules.core.utilities.ifNull
 
 class GroupViewManagerWrapper(
@@ -17,9 +17,29 @@ class GroupViewManagerWrapper(
   override fun createViewInstance(reactContext: ThemedReactContext): ViewGroup =
     viewWrapperDelegate.createView(reactContext) as ViewGroup
 
-  @ReactProp(name = "proxiedProperties")
-  fun setProxiedProperties(view: View, proxiedProperties: ReadableMap) {
-    viewWrapperDelegate.setProxiedProperties(view, proxiedProperties)
+  override fun updateProperties(viewToUpdate: ViewGroup, props: ReactStylesDiffMap) {
+    val propsMap = props.getBackingMap()
+    // Updates expo related properties.
+    val handledProps = viewWrapperDelegate.updateProperties(viewToUpdate, propsMap)
+    // Updates remaining props using RN implementation.
+    // To not triggered undefined setters we filtrated already handled properties.
+    super.updateProperties(
+      viewToUpdate,
+      ReactStylesDiffMap(FilteredReadableMap(propsMap, handledProps))
+    )
+  }
+
+  override fun onAfterUpdateTransaction(view: ViewGroup) {
+    super.onAfterUpdateTransaction(view)
+    viewWrapperDelegate.onViewDidUpdateProps(view)
+  }
+
+  override fun getNativeProps(): MutableMap<String, String> {
+    val props = super.getNativeProps()
+    viewWrapperDelegate.props.forEach { (key, prop) ->
+      props[key] = prop.type.kType.toString()
+    }
+    return props
   }
 
   override fun onDropViewInstance(view: ViewGroup) {

package/android/src/main/java/expo/modules/kotlin/views/SimpleViewManagerWrapper.kt

@@ -1,11 +1,11 @@
 package expo.modules.kotlin.views
 
 import android.view.View
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ReactStylesDiffMap
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.getBackingMap
 
 class SimpleViewManagerWrapper(
   override val viewWrapperDelegate: ViewManagerWrapperDelegate
@@ -15,9 +15,29 @@ class SimpleViewManagerWrapper(
   override fun createViewInstance(reactContext: ThemedReactContext): View =
     viewWrapperDelegate.createView(reactContext)
 
-  @ReactProp(name = "proxiedProperties")
-  fun setProxiedProperties(view: View, proxiedProperties: ReadableMap) {
-    viewWrapperDelegate.setProxiedProperties(view, proxiedProperties)
+  override fun updateProperties(viewToUpdate: View, props: ReactStylesDiffMap) {
+    val propsMap = props.getBackingMap()
+    // Updates expo related properties.
+    val handledProps = viewWrapperDelegate.updateProperties(viewToUpdate, propsMap)
+    // Updates remaining props using RN implementation.
+    // To not triggered undefined setters we filtrated already handled properties.
+    super.updateProperties(
+      viewToUpdate,
+      ReactStylesDiffMap(FilteredReadableMap(propsMap, handledProps))
+    )
+  }
+
+  override fun onAfterUpdateTransaction(view: View) {
+    super.onAfterUpdateTransaction(view)
+    viewWrapperDelegate.onViewDidUpdateProps(view)
+  }
+
+  override fun getNativeProps(): MutableMap<String, String> {
+    val props = super.getNativeProps()
+    viewWrapperDelegate.props.forEach { (key, prop) ->
+      props[key] = prop.type.kType.toString()
+    }
+    return props
   }
 
   override fun onDropViewInstance(view: View) {

package/android/src/main/java/expo/modules/kotlin/views/ViewDefinitionBuilder.kt

@@ -8,17 +8,27 @@ import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.functions.AsyncFunction
+import expo.modules.kotlin.functions.AsyncFunctionBuilder
+import expo.modules.kotlin.functions.AsyncFunctionComponent
+import expo.modules.kotlin.functions.AsyncFunctionWithPromiseComponent
+import expo.modules.kotlin.functions.Queues
 import expo.modules.kotlin.modules.DefinitionMarker
 import expo.modules.kotlin.types.toAnyType
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
+import kotlin.reflect.KType
 import kotlin.reflect.full.primaryConstructor
 import kotlin.reflect.typeOf
 
 @DefinitionMarker
-class ViewDefinitionBuilder<T : View>(@PublishedApi internal val viewType: KClass<T>) {
+class ViewDefinitionBuilder<T : View>(
+  @PublishedApi internal val viewClass: KClass<T>,
+  @PublishedApi internal val viewType: KType
+) {
   @PublishedApi
   internal var props = mutableMapOf<String, AnyViewProp>()
 
@@ -32,16 +42,29 @@ class ViewDefinitionBuilder<T : View>(@PublishedApi internal val viewType: KClas
   internal var viewGroupDefinition: ViewGroupDefinition? = null
   private var callbacksDefinition: CallbacksDefinition? = null
 
-  fun build(): ViewManagerDefinition =
-    ViewManagerDefinition(
+  @PublishedApi
+  internal var asyncFunctions = mutableMapOf<String, AsyncFunction>()
+
+  private var functionBuilders = mutableMapOf<String, AsyncFunctionBuilder>()
+
+  fun build(): ViewManagerDefinition {
+    val asyncFunctions = asyncFunctions + functionBuilders.mapValues { (_, value) -> value.build() }
+    asyncFunctions.forEach { (_, function) ->
+      function.runOnQueue(Queues.MAIN)
+      function.ownerType = viewType
+    }
+
+    return ViewManagerDefinition(
       viewFactory = createViewFactory(),
-      viewType = viewType.java,
+      viewType = viewClass.java,
       props = props,
       onViewDestroys = onViewDestroys,
       callbacksDefinition = callbacksDefinition,
       viewGroupDefinition = viewGroupDefinition,
-      onViewDidUpdateProps = onViewDidUpdateProps
+      onViewDidUpdateProps = onViewDidUpdateProps,
+      asyncFunctions = asyncFunctions.values.toList(),
     )
+  }
 
   /**
    * Creates view's lifecycle listener that is called right after the view isn't longer used by React Native.
@@ -127,7 +150,7 @@ class ViewDefinitionBuilder<T : View>(@PublishedApi internal val viewType: KClas
    * Creates the group view definition that scopes group view-related definitions.
    */
   inline fun <reified ParentType : ViewGroup> GroupView(body: ViewGroupDefinitionBuilder<ParentType>.() -> Unit) {
-    assert(viewType == ParentType::class) { "Provided type and view type have to be the same." }
+    assert(viewClass == ParentType::class) { "Provided type and view type have to be the same." }
     require(viewGroupDefinition == null) { "The viewManager definition may have exported only one groupView definition." }
 
     val groupViewDefinitionBuilder = ViewGroupDefinitionBuilder<ParentType>()
@@ -135,8 +158,136 @@ class ViewDefinitionBuilder<T : View>(@PublishedApi internal val viewType: KClas
     viewGroupDefinition = groupViewDefinitionBuilder.build()
   }
 
+  @JvmName("AsyncFunctionWithoutArgs")
+  inline fun AsyncFunction(
+    name: String,
+    crossinline body: () -> Any?
+  ): AsyncFunction {
+    return AsyncFunctionComponent(name, arrayOf()) { body() }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R> AsyncFunction(
+    name: String,
+    crossinline body: () -> R
+  ): AsyncFunction {
+    return AsyncFunctionComponent(name, arrayOf()) { body() }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R, reified P0> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0) -> R
+  ): AsyncFunction {
+    return if (P0::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf()) { _, promise -> body(promise as P0) }
+    } else {
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+    }.also {
+      it.ownerType = viewType
+      asyncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1) -> R
+  ): AsyncFunction {
+    return if (P1::class == Promise::class) {
+      AsyncFunctionWithPromiseComponent(name, arrayOf(typeOf<P0>().toAnyType())) { args, promise -> body(args[0] as P0, promise as P1) }
+    } else {
+      AsyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2) -> R
+  ): AsyncFunction {
+    return 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 {
+      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) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  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
+  ): AsyncFunction {
+    return 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 {
+      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) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  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
+  ): AsyncFunction {
+    return 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 {
+      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) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  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
+  ): AsyncFunction {
+    return 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 {
+      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) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  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
+  ): AsyncFunction {
+    return 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 {
+      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) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  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
+  ): AsyncFunction {
+    return 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 {
+      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) }
+    }.also {
+      asyncFunctions[name] = it
+    }
+  }
+
+  fun AsyncFunction(
+    name: String
+  ) = AsyncFunctionBuilder(name).also { functionBuilders[name] = it }
+
   private fun createViewFactory(): (Context, AppContext) -> View = viewFactory@{ context: Context, appContext: AppContext ->
-    val primaryConstructor = requireNotNull(getPrimaryConstructor()) { "$viewType doesn't have a primary constructor" }
+    val primaryConstructor = requireNotNull(getPrimaryConstructor()) { "$viewClass doesn't have a primary constructor" }
     val args = primaryConstructor.parameters
 
     if (args.isEmpty()) {
@@ -174,7 +325,7 @@ class ViewDefinitionBuilder<T : View>(@PublishedApi internal val viewType: KClas
   }
 
   private fun handleFailureDuringViewCreation(context: Context, appContext: AppContext, e: Throwable): View {
-    Log.e("ExpoModulesCore", "Couldn't create view of type $viewType", e)
+    Log.e("ExpoModulesCore", "Couldn't create view of type $viewClass", e)
 
     appContext.errorManager?.reportExceptionToLogBox(
       if (e is CodedException) {
@@ -187,12 +338,12 @@ class ViewDefinitionBuilder<T : View>(@PublishedApi internal val viewType: KClas
   }
 
   private fun getPrimaryConstructor(): KFunction<T>? {
-    val kotlinContractor = viewType.primaryConstructor
+    val kotlinContractor = viewClass.primaryConstructor
     if (kotlinContractor != null) {
       return kotlinContractor
     }
 
     // Add compatibility with Java
-    return viewType.constructors.firstOrNull()
+    return viewClass.constructors.firstOrNull()
   }
 }

package/android/src/main/java/expo/modules/kotlin/views/ViewGroupDefinitionBuilder.kt

@@ -76,70 +76,3 @@ class ViewGroupDefinitionBuilder<ParentType : ViewGroup> {
     }
   }
 }
-
-@Deprecated("Use `ViewGroupDefinitionBuilder` instead.")
-@DefinitionMarker
-class ViewGroupDefinitionLegacyBuilder {
-  @PublishedApi
-  internal var addViewAction: AddViewAction? = null
-
-  @PublishedApi
-  internal var getChildAtAction: GetChildAtAction? = null
-
-  @PublishedApi
-  internal var getChildCountAction: GetChildCountAction? = null
-
-  @PublishedApi
-  internal var removeViewAction: RemoveViewAction? = null
-
-  @PublishedApi
-  internal var removeViewAtAction: RemoveViewAtAction? = null
-
-  fun build() = ViewGroupDefinition(
-    addViewAction,
-    getChildAtAction,
-    getChildCountAction,
-    removeViewAction,
-    removeViewAtAction
-  )
-
-  inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> AddChildView(
-    noinline body: (parent: ParentViewType, child: ChildViewType, index: Int) -> Unit
-  ) {
-    addViewAction = { parent, child, index ->
-      body(parent as ParentViewType, child as ChildViewType, index)
-    }
-  }
-
-  inline fun <reified ParentViewType : ViewGroup> GetChildCount(
-    noinline body: (view: ParentViewType) -> Int
-  ) {
-    getChildCountAction = { view ->
-      body(view as ParentViewType)
-    }
-  }
-
-  inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> GetChildViewAt(
-    noinline body: (view: ParentViewType, index: Int) -> ChildViewType?
-  ) {
-    getChildAtAction = { view, index ->
-      body(view as ParentViewType, index)
-    }
-  }
-
-  inline fun <reified ParentViewType : ViewGroup> RemoveChildViewAt(
-    noinline body: (view: ParentViewType, index: Int) -> Unit
-  ) {
-    removeViewAtAction = { view, index ->
-      body(view as ParentViewType, index)
-    }
-  }
-
-  inline fun <reified ParentViewType : ViewGroup, reified ChildViewType : View> RemoveChildView(
-    noinline body: (parent: ParentViewType, child: ChildViewType) -> Unit
-  ) {
-    removeViewAction = { view, child ->
-      body(view as ParentViewType, child as ChildViewType)
-    }
-  }
-}

package/android/src/main/java/expo/modules/kotlin/views/ViewManagerDefinition.kt

@@ -10,18 +10,20 @@ import expo.modules.core.ViewManager
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.DynamicNull
 import expo.modules.kotlin.exception.CodedException
-import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.exception.toCodedException
+import expo.modules.kotlin.functions.BaseAsyncFunctionComponent
 import expo.modules.kotlin.logger
 import expo.modules.kotlin.recycle
 
 class ViewManagerDefinition(
   private val viewFactory: (Context, AppContext) -> View,
-  private val viewType: Class<out View>,
-  private val props: Map<String, AnyViewProp>,
+  internal val viewType: Class<out View>,
+  internal val props: Map<String, AnyViewProp>,
   val onViewDestroys: ((View) -> Unit)? = null,
   val callbacksDefinition: CallbacksDefinition? = null,
   val viewGroupDefinition: ViewGroupDefinition? = null,
-  val onViewDidUpdateProps: ((View) -> Unit)? = null
+  val onViewDidUpdateProps: ((View) -> Unit)? = null,
+  val asyncFunctions: List<BaseAsyncFunctionComponent> = emptyList()
 ) {
 
   fun createView(context: Context, appContext: AppContext): View = viewFactory(context, appContext)
@@ -53,10 +55,7 @@ class ViewManagerDefinition(
 
         handleException(
           onView,
-          when (exception) {
-            is CodedException -> exception
-            else -> UnexpectedException(exception)
-          }
+          exception.toCodedException()
         )
       }
     }