expo-modules-core 1.2.7 → 1.3.0

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,
   internal val viewType: Class<out View>,
-  private val props: Map<String, AnyViewProp>,
+  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()
         )
       }
     }

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

@@ -7,6 +7,9 @@ import com.facebook.react.common.MapBuilder
 import expo.modules.core.utilities.ifNull
 import expo.modules.kotlin.ModuleHolder
 import expo.modules.kotlin.events.normalizeEventName
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.OnViewDidUpdatePropsException
+import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.logger
 import expo.modules.kotlin.viewevent.ViewEventDelegate
 import kotlin.reflect.full.declaredMemberProperties
@@ -22,6 +25,9 @@ class ViewManagerWrapperDelegate(internal var moduleHolder: ModuleHolder) {
   val name: String
     get() = moduleHolder.name
 
+  val props: Map<String, AnyViewProp>
+    get() = definition.props
+
   fun createView(context: Context): View {
     return definition
       .createView(context, moduleHolder.module.appContext)
@@ -30,9 +36,40 @@ class ViewManagerWrapperDelegate(internal var moduleHolder: ModuleHolder) {
       }
   }
 
-  fun setProxiedProperties(view: View, proxiedProperties: ReadableMap) {
-    definition.setProps(proxiedProperties, view)
-    definition.onViewDidUpdateProps?.invoke(view)
+  fun onViewDidUpdateProps(view: View) {
+    definition.onViewDidUpdateProps?.let {
+      try {
+        exceptionDecorator({ OnViewDidUpdatePropsException(view.javaClass.kotlin, it) }) {
+          it.invoke(view)
+        }
+      } catch (exception: CodedException) {
+        logger.error("❌ Error occurred when invoking 'onViewDidUpdateProps' on '${view.javaClass.simpleName}'", exception)
+        definition.handleException(view, exception)
+      }
+    }
+  }
+
+  /**
+   * Updates the expo related properties of a given View based on a ReadableMap of property values.
+   *
+   * @param view The View whose properties should be updated.
+   * @param propsMap A ReadableMap of property values.
+   *
+   * @return A List of property names that were successfully updated.
+   */
+  fun updateProperties(view: View, propsMap: ReadableMap): List<String> {
+    val expoProps = props
+    val handledProps = mutableListOf<String>()
+    val iterator = propsMap.keySetIterator()
+
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      expoProps[key]?.let { expoProp ->
+        expoProp.set(propsMap.getDynamic(key), view)
+        handledProps.add(key)
+      }
+    }
+    return handledProps
   }
 
   fun onDestroy(view: View) =

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

@@ -0,0 +1,44 @@
+package expo.modules.kotlin.views
+
+import android.view.View
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.Utils
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.exception.NullArgumentException
+import expo.modules.kotlin.jni.CppType
+import expo.modules.kotlin.jni.ExpectedType
+import expo.modules.kotlin.toStrongReference
+import expo.modules.kotlin.types.TypeConverter
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+
+class ViewTypeConverter<T : View>(
+  val type: KType
+) : TypeConverter<T>() {
+
+  override fun convert(value: Any?, context: AppContext?): T? {
+    Utils.assertMainThread()
+    if (value == null) {
+      if (type.isMarkedNullable) {
+        return null
+      }
+      throw NullArgumentException()
+    }
+
+    val appContext = context.toStrongReference()
+    val viewTag = value as Int
+    val view = appContext.findView<T>(viewTag)
+    if (!type.isMarkedNullable && view == null) {
+      throw Exceptions.ViewNotFound(type.classifier as KClass<*>, viewTag)
+    }
+
+    return view
+  }
+
+  override fun getCppRequiredTypes(): ExpectedType = ExpectedType(
+    CppType.INT,
+    CppType.VIEW_TAG
+  )
+
+  override fun isTrivial(): Boolean = false
+}

package/android-annotation/build.gradle

@@ -0,0 +1,45 @@
+apply plugin: 'java-library'
+apply plugin: 'org.jetbrains.kotlin.jvm'
+apply plugin: 'kotlin'
+
+group = 'host.exp.exponent'
+version = '1.1.1'
+
+buildscript {
+  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+  if (expoModulesCorePlugin.exists()) {
+    apply from: expoModulesCorePlugin
+    applyKotlinExpoModulesCorePlugin()
+  }
+
+  // Simple helper that allows the root project to override versions declared by this library.
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+
+  // Ensures backward compatibility
+  ext.getKotlinVersion = {
+    if (ext.has("kotlinVersion")) {
+      ext.kotlinVersion()
+    } else {
+      ext.safeExtGet("kotlinVersion", "1.6.10")
+    }
+  }
+
+  repositories {
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+  }
+}
+
+java {
+  sourceCompatibility = JavaVersion.VERSION_1_8
+  targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+}

package/android-annotation/src/main/java/expo/modules/annotation/Config.kt

@@ -0,0 +1,7 @@
+package expo.modules.annotation
+
+object Config {
+  const val packageNamePrefix = "expo.modules.generated."
+  const val classNameSuffix = "_ExpoTypeConverterProvider"
+  const val converterProviderFunctionName = "converter"
+}

package/android-annotation/src/main/java/expo/modules/annotation/ConverterBinder.kt

@@ -0,0 +1,7 @@
+package expo.modules.annotation
+
+import kotlin.reflect.KClass
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS)
+annotation class ConverterBinder(val clazz: KClass<*> = Nothing::class)