expo-modules-core 0.6.1 → 0.7.0

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

@@ -31,7 +31,8 @@ import expo.modules.kotlin.views.ViewManagerDefinition
 import expo.modules.kotlin.views.ViewManagerDefinitionBuilder
 import kotlin.reflect.typeOf
 
-class ModuleDefinitionBuilder {
+@DefinitionMarker
+class ModuleDefinitionBuilder(private val module: Module? = null) {
   private var name: String? = null
   private var constantsProvider = { emptyMap<String, Any?>() }
   private var eventsDefinition: EventsDefinition? = null
@@ -46,8 +47,10 @@ 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,
       viewManagerDefinition,
@@ -56,14 +59,27 @@ class ModuleDefinitionBuilder {
     )
   }
 
+  /**
+   * 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
   }
 
+  /**
+   * Definition of the module's constants to export.
+   */
+  fun constants(vararg constants: Pair<String, Any?>) {
+    constantsProvider = { constants.toMap() }
+  }
+
   @JvmName("methodWithoutArgs")
   inline fun function(
     name: String,
@@ -167,6 +183,9 @@ class ModuleDefinitionBuilder {
     }
   }
 
+  /**
+   * 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 +194,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 +237,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)
   }
 
   /**
-   * 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)
   }
 
+  /**
+   * 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/records/Record.kt

@@ -1,3 +1,42 @@
 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

@@ -3,6 +3,10 @@ package expo.modules.kotlin.records
 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.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
@@ -18,7 +22,7 @@ class RecordTypeConverter<T : Record>(
 ) : TypeConverter<T>(type.isMarkedNullable) {
   private val objectConstructorFactory = ObjectConstructorFactory()
 
-  override fun convertNonOptional(value: Dynamic): T {
+  override fun convertNonOptional(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
     val jsMap = value.asMap()
 
     val kClass = type.classifier as KClass<*>
@@ -35,14 +39,17 @@ class RecordTypeConverter<T : Record>(
           return@map
         }
 
-        val value = jsMap.getDynamic(jsKey)
-        val javaField = property.javaField!!
+        jsMap.getDynamic(jsKey).recycle {
+          val javaField = property.javaField!!
 
-        val elementConverter = converterProvider.obtainTypeConverter(property.returnType)
-        val casted = elementConverter.convert(value)
+          val elementConverter = converterProvider.obtainTypeConverter(property.returnType)
+          val casted = exceptionDecorator({ cause -> FieldCastException(property.name, property.returnType, type, cause) }) {
+            elementConverter.convert(this)
+          }
 
-        javaField.isAccessible = true
-        javaField.set(instance, casted)
+          javaField.isAccessible = true
+          javaField.set(instance, casted)
+        }
       }
 
     @Suppress("UNCHECKED_CAST")

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

@@ -1,16 +1,18 @@
 package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.exception.CollectionElementCastException
+import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
 
 class ArrayTypeConverter(
   converterProvider: TypeConverterProvider,
-  private val type: KType,
-) : TypeConverter<Array<*>>(type.isMarkedNullable) {
+  private val arrayType: KType,
+) : TypeConverter<Array<*>>(arrayType.isMarkedNullable) {
   private val arrayElementConverter = converterProvider.obtainTypeConverter(
-    requireNotNull(type.arguments.first().type) {
+    requireNotNull(arrayType.arguments.first().type) {
       "The array type should contain the type of the elements."
     }
   )
@@ -22,7 +24,11 @@ class ArrayTypeConverter(
       array[i] = jsArray
         .getDynamic(i)
         .recycle {
-          arrayElementConverter.convert(this)
+          exceptionDecorator({ cause ->
+            CollectionElementCastException(arrayType, arrayType.arguments.first().type!!, type, cause)
+          }) {
+            arrayElementConverter.convert(this)
+          }
         }
     }
     return array
@@ -37,7 +43,7 @@ class ArrayTypeConverter(
   @Suppress("UNCHECKED_CAST")
   private fun createTypedArray(size: Int): Array<Any?> {
     return java.lang.reflect.Array.newInstance(
-      (type.arguments.first().type!!.classifier as KClass<*>).java,
+      (arrayType.arguments.first().type!!.classifier as KClass<*>).java,
       size
     ) as Array<Any?>
   }

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

@@ -1,15 +1,17 @@
 package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.exception.CollectionElementCastException
+import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KType
 
 class ListTypeConverter(
   converterProvider: TypeConverterProvider,
-  type: KType,
-) : TypeConverter<List<*>>(type.isMarkedNullable) {
+  private val listType: KType,
+) : TypeConverter<List<*>>(listType.isMarkedNullable) {
   private val elementConverter = converterProvider.obtainTypeConverter(
-    requireNotNull(type.arguments.first().type) {
+    requireNotNull(listType.arguments.first().type) {
       "The list type should contain the type of elements."
     }
   )
@@ -18,7 +20,11 @@ class ListTypeConverter(
     val jsArray = value.asArray()
     return List(jsArray.size()) { index ->
       jsArray.getDynamic(index).recycle {
-        elementConverter.convert(this)
+        exceptionDecorator({ cause ->
+          CollectionElementCastException(listType, listType.arguments.first().type!!, type, cause)
+        }) {
+          elementConverter.convert(this)
+        }
       }
     }
   }

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

@@ -4,22 +4,24 @@ package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
 import com.facebook.react.bridge.DynamicFromObject
+import expo.modules.kotlin.exception.CollectionElementCastException
+import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KType
 import kotlin.reflect.typeOf
 
 class MapTypeConverter(
   converterProvider: TypeConverterProvider,
-  type: KType
-) : TypeConverter<Map<*, *>>(type.isMarkedNullable) {
+  private val mapType: KType
+) : TypeConverter<Map<*, *>>(mapType.isMarkedNullable) {
   init {
-    require(type.arguments.first().type == typeOf<String>()) {
-      "The map key type should be String, but received ${type.arguments.first()}."
+    require(mapType.arguments.first().type == typeOf<String>()) {
+      "The map key type should be String, but received ${mapType.arguments.first()}."
     }
   }
 
   private val valueConverter = converterProvider.obtainTypeConverter(
-    requireNotNull(type.arguments.getOrNull(1)?.type) {
+    requireNotNull(mapType.arguments.getOrNull(1)?.type) {
       "The map type should contain the key type."
     }
   )
@@ -30,7 +32,11 @@ class MapTypeConverter(
 
     jsMap.entryIterator.forEach { (key, value) ->
       DynamicFromObject(value).recycle {
-        result[key] = valueConverter.convert(this)
+        exceptionDecorator({ cause ->
+          CollectionElementCastException(mapType, mapType.arguments[1].type!!, type, cause)
+        }) {
+          result[key] = valueConverter.convert(this)
+        }
       }
     }
 

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

@@ -1,28 +1,44 @@
 package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.exception.CollectionElementCastException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.recycle
 import kotlin.reflect.KType
 
 class PairTypeConverter(
   converterProvider: TypeConverterProvider,
-  type: KType,
-) : TypeConverter<Pair<*, *>>(type.isMarkedNullable) {
-  private val firstConverter = converterProvider.obtainTypeConverter(
-    requireNotNull(type.arguments.getOrNull(0)?.type) {
-      "The pair type should contain the type of the first parameter."
-    }
-  )
-  private val secondConverter = converterProvider.obtainTypeConverter(
-    requireNotNull(type.arguments.getOrNull(1)?.type) {
-      "The pair type should contain the type of the second parameter."
-    }
+  private val pairType: KType,
+) : TypeConverter<Pair<*, *>>(pairType.isMarkedNullable) {
+  private val converters = listOf(
+    converterProvider.obtainTypeConverter(
+      requireNotNull(pairType.arguments.getOrNull(0)?.type) {
+        "The pair type should contain the type of the first parameter."
+      }
+    ),
+    converterProvider.obtainTypeConverter(
+      requireNotNull(pairType.arguments.getOrNull(1)?.type) {
+        "The pair type should contain the type of the second parameter."
+      }
+    )
   )
 
   override fun convertNonOptional(value: Dynamic): Pair<*, *> {
     val jsArray = value.asArray()
     return Pair(
-      firstConverter.convert(jsArray.getDynamic(0)),
-      secondConverter.convert(jsArray.getDynamic(1)),
+      convertElement(jsArray, 0),
+      convertElement(jsArray, 1)
     )
   }
+
+  private fun convertElement(array: ReadableArray, index: Int): Any? {
+    return array.getDynamic(index).recycle {
+      exceptionDecorator({ cause ->
+        CollectionElementCastException(pairType, pairType.arguments[index].type!!, type, cause)
+      }) {
+        converters[index].convert(this)
+      }
+    }
+  }
 }

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

@@ -1,6 +1,7 @@
 package expo.modules.kotlin.types
 
 import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.exception.NullArgumentException
 
 abstract class TypeConverter<Type : Any>(
   private val isOptional: Boolean
@@ -10,7 +11,7 @@ abstract class TypeConverter<Type : Any>(
       if (isOptional) {
         return null
       }
-      throw IllegalArgumentException()
+      throw NullArgumentException()
     }
     return convertNonOptional(value)
   }

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

@@ -0,0 +1,3 @@
+package expo.modules.kotlin.views
+
+class CallbacksDefinition(val names: Array<out String>)

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

@@ -3,6 +3,7 @@ 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.ThemedReactContext
 import com.facebook.react.uimanager.ViewGroupManager
 import com.facebook.react.uimanager.annotations.ReactProp
@@ -19,4 +20,25 @@ class GroupViewManagerWrapper(
   fun setProxiedProperties(view: View, proxiedProperties: ReadableMap) {
     viewWrapperDelegate.setProxiedProperties(view, proxiedProperties)
   }
+
+  override fun onDropViewInstance(view: ViewGroup) {
+    super.onDropViewInstance(view)
+    viewWrapperDelegate.onDestroy(view)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+    viewWrapperDelegate.getExportedCustomDirectEventTypeConstants()?.let {
+      val directEvents = super.getExportedCustomDirectEventTypeConstants() ?: emptyMap()
+      val builder = MapBuilder.builder<String, Any>()
+      directEvents.forEach { event ->
+        builder.put(event.key, event.value)
+      }
+      it.forEach { event ->
+        builder.put(event.key, event.value)
+      }
+      return builder.build()
+    }
+
+    return super.getExportedCustomDirectEventTypeConstants()
+  }
 }

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

@@ -2,6 +2,7 @@ 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.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
@@ -18,4 +19,25 @@ class SimpleViewManagerWrapper(
   fun setProxiedProperties(view: View, proxiedProperties: ReadableMap) {
     viewWrapperDelegate.setProxiedProperties(view, proxiedProperties)
   }
+
+  override fun onDropViewInstance(view: View) {
+    super.onDropViewInstance(view)
+    viewWrapperDelegate.onDestroy(view)
+  }
+
+  override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+    viewWrapperDelegate.getExportedCustomDirectEventTypeConstants()?.let {
+      val directEvents = super.getExportedCustomDirectEventTypeConstants() ?: emptyMap()
+      val builder = MapBuilder.builder<String, Any>()
+      directEvents.forEach { event ->
+        builder.put(event.key, event.value)
+      }
+      it.forEach { event ->
+        builder.put(event.key, event.value)
+      }
+      return builder.build()
+    }
+
+    return super.getExportedCustomDirectEventTypeConstants()
+  }
 }

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

@@ -4,14 +4,20 @@ import android.content.Context
 import android.util.Log
 import android.view.View
 import android.view.ViewGroup
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
+import expo.modules.adapters.react.NativeModulesProxy
 import expo.modules.core.ViewManager
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.UnexpectedException
 import expo.modules.kotlin.recycle
 
 class ViewManagerDefinition(
   private val viewFactory: (Context) -> View,
   private val viewType: Class<out View>,
-  private val props: Map<String, AnyViewProp>
+  private val props: Map<String, AnyViewProp>,
+  val onViewDestroys: ((View) -> Unit)? = null,
+  val callbacksDefinition: CallbacksDefinition? = null
 ) {
 
   fun createView(context: Context): View = viewFactory(context)
@@ -33,9 +39,28 @@ class ViewManagerDefinition(
         try {
           propDelegate.set(this, onView)
         } catch (exception: Throwable) {
-          Log.e("ExpoModulesCore", "Cannot set the $key prop on the ${viewType.simpleName}.", exception)
+          Log.e("ExpoModulesCore", "Cannot set the '$key' prop on the '${viewType.simpleName}'.", exception)
+
+          handleException(
+            onView,
+            when (exception) {
+              is CodedException -> exception
+              else -> UnexpectedException(exception)
+            }
+          )
         }
       }
     }
   }
+
+  fun handleException(view: View, exception: CodedException) {
+    val reactContext = (view.context as? ReactContext) ?: return
+    val nativeModulesProxy = reactContext
+      .catalystInstance
+      ?.getNativeModule("NativeUnimoduleProxy") as? NativeModulesProxy
+      ?: return
+    val appContext = nativeModulesProxy.kotlinInteropModuleRegistry.appContext
+
+    appContext.errorManager?.reportExceptionToLogBox(exception)
+  }
 }

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

@@ -4,9 +4,11 @@ package expo.modules.kotlin.views
 
 import android.content.Context
 import android.view.View
+import expo.modules.kotlin.modules.DefinitionMarker
 import expo.modules.kotlin.types.toAnyType
 import kotlin.reflect.typeOf
 
+@DefinitionMarker
 class ViewManagerDefinitionBuilder {
   @PublishedApi
   internal var viewFactory: ((Context) -> View)? = null
@@ -14,19 +16,38 @@ class ViewManagerDefinitionBuilder {
   internal var viewType: Class<out View>? = null
   @PublishedApi
   internal var props = mutableMapOf<String, AnyViewProp>()
+  @PublishedApi
+  internal var onViewDestroys: ((View) -> Unit)? = null
+
+  private var callbacksDefinition: CallbacksDefinition? = null
 
   fun build(): ViewManagerDefinition =
     ViewManagerDefinition(
       requireNotNull(viewFactory),
       requireNotNull(viewType),
-      props
+      props,
+      onViewDestroys,
+      callbacksDefinition
     )
 
+  /**
+   * Defines the factory creating a native view when the module is used as a view.
+   */
   inline fun <reified ViewType : View> view(noinline body: (Context) -> ViewType) {
     viewType = ViewType::class.java
     viewFactory = body
   }
 
+  /**
+   * Creates view's lifecycle listener that is called right after the view isn't longer used by React Native.
+   */
+  inline fun <reified ViewType : View> onViewDestroys(noinline body: (view: ViewType) -> Unit) {
+    onViewDestroys = { body(it as ViewType) }
+  }
+
+  /**
+   * Creates a view prop that defines its name and setter.
+   */
   inline fun <reified ViewType : View, reified PropType> prop(
     name: String,
     noinline body: (view: ViewType, prop: PropType) -> Unit
@@ -37,4 +58,11 @@ class ViewManagerDefinitionBuilder {
       body
     )
   }
+
+  /**
+   * Defines prop names that should be treated as callbacks.
+   */
+  fun events(vararg callbacks: String) {
+    callbacksDefinition = CallbacksDefinition(callbacks)
+  }
 }

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

@@ -1,9 +1,15 @@
 package expo.modules.kotlin.views
 
 import android.content.Context
+import android.util.Log
 import android.view.View
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import expo.modules.core.utilities.ifNull
 import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.callbacks.ViewCallbackDelegate
+import kotlin.reflect.full.declaredMemberProperties
+import kotlin.reflect.jvm.isAccessible
 
 class ViewManagerWrapperDelegate(internal var moduleHolder: ModuleHolder) {
   private val definition: ViewManagerDefinition
@@ -12,10 +18,61 @@ class ViewManagerWrapperDelegate(internal var moduleHolder: ModuleHolder) {
   val name: String
     get() = moduleHolder.name
 
-  fun createView(context: Context): View =
-    definition.createView(context)
+  fun createView(context: Context): View {
+    return definition
+      .createView(context)
+      .also {
+        configureView(it)
+      }
+  }
 
   fun setProxiedProperties(view: View, proxiedProperties: ReadableMap) {
     definition.setProps(proxiedProperties, view)
   }
+
+  fun onDestroy(view: View) =
+    definition.onViewDestroys?.invoke(view)
+
+  fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+    val builder = MapBuilder.builder<String, Any>()
+    definition
+      .callbacksDefinition
+      ?.names
+      ?.forEach {
+        builder.put(
+          it, MapBuilder.of<String, Any>("registrationName", it)
+        )
+      }
+    return builder.build()
+  }
+
+  private fun configureView(view: View) {
+    val callbacks = definition.callbacksDefinition?.names ?: return
+
+    val kClass = view.javaClass.kotlin
+    val propertiesMap = kClass
+      .declaredMemberProperties
+      .map { it.name to it }
+      .toMap()
+
+    callbacks.forEach {
+      val property = propertiesMap[it].ifNull {
+        Log.w("ExpoModuleCore", "Property `$it` does not exist in ${kClass.simpleName}.")
+        return@forEach
+      }
+      property.isAccessible = true
+
+      val delegate = property.getDelegate(view).ifNull {
+        Log.w("ExpoModulesCore", "Property delegate for `$it` in ${kClass.simpleName} does not exist.")
+        return@forEach
+      }
+
+      val viewDelegate = (delegate as? ViewCallbackDelegate<*>).ifNull {
+        Log.w("ExpoModulesCore", "Property delegate for `$it` cannot be cased to `ViewCallbackDelegate`.")
+        return@forEach
+      }
+
+      viewDelegate.isValidated = true
+    }
+  }
 }