expo-modules-core 0.4.9 → 0.6.2

package/android/src/main/java/expo/modules/kotlin/methods/PromiseMethod.kt

@@ -0,0 +1,15 @@
+package expo.modules.kotlin.methods
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+
+class PromiseMethod(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: (args: Array<out Any?>, promise: Promise) -> Unit
+) : AnyMethod(name, argsType) {
+
+  override fun callImplementation(args: Array<out Any?>, promise: Promise) {
+    body(args, promise)
+  }
+}

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

@@ -0,0 +1,24 @@
+package expo.modules.kotlin.modules
+
+import android.os.Bundle
+import expo.modules.kotlin.AppContext
+
+abstract class Module {
+  internal var _appContext: AppContext? = null
+
+  private val moduleEventEmitter by lazy { appContext.eventEmitter(this) }
+
+  val appContext: AppContext
+    get() = requireNotNull(_appContext) { "The module wasn't created! You can't access the app context." }
+
+  fun sendEvent(name: String, body: Bundle?) {
+    moduleEventEmitter?.emit(name, body)
+  }
+
+  abstract fun definition(): ModuleDefinitionData
+}
+
+@Suppress("FunctionName")
+inline fun ModuleDefinition(block: ModuleDefinitionBuilder.() -> Unit): ModuleDefinitionData {
+  return ModuleDefinitionBuilder().also(block).build()
+}

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

@@ -0,0 +1,227 @@
+/**
+ * We used a function from the experimental STD API - typeOf (see kotlinlang.org/api/latest/jvm/stdlib/kotlin.reflect/type-of.html).
+ * We shouldn't have any problem with that function, cause it's widely used in other libraries created by JetBrains like kotlinx-serializer.
+ * This function is super handy if we want to receive a collection type.
+ * For example, it's very hard to obtain the generic parameter type from the list class.
+ * In plain Java, it's almost impossible. There is a trick to getting such information using something called TypeToken.
+ * For instance, the Gson library uses this workaround. But there still will be a problem with nullability.
+ * We didn't find a good solution to distinguish between List<Any?> and List<Any>.
+ * Mainly because from the JVM perspective it's the same type.
+ * That's why we used typeOf. It solves all problems described above.
+ */
+@file:OptIn(ExperimentalStdlibApi::class)
+
+package expo.modules.kotlin.modules
+
+import android.app.Activity
+import android.content.Intent
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.events.BasicEventListener
+import expo.modules.kotlin.events.EventListener
+import expo.modules.kotlin.events.EventListenerWithPayload
+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.types.toAnyType
+import expo.modules.kotlin.views.ViewManagerDefinition
+import expo.modules.kotlin.views.ViewManagerDefinitionBuilder
+import kotlin.reflect.typeOf
+
+class ModuleDefinitionBuilder {
+  private var name: String? = null
+  private var constantsProvider = { emptyMap<String, Any?>() }
+  private var eventsDefinition: EventsDefinition? = null
+
+  @PublishedApi
+  internal var methods = mutableMapOf<String, AnyMethod>()
+
+  @PublishedApi
+  internal var viewManagerDefinition: ViewManagerDefinition? = null
+
+  @PublishedApi
+  internal val eventListeners = mutableMapOf<EventName, EventListener>()
+
+  fun build(): ModuleDefinitionData {
+    return ModuleDefinitionData(
+      requireNotNull(name),
+      constantsProvider,
+      methods,
+      viewManagerDefinition,
+      eventListeners,
+      eventsDefinition
+    )
+  }
+
+  fun name(name: String) {
+    this.name = name
+  }
+
+  fun constants(constantsProvider: () -> Map<String, Any?>) {
+    this.constantsProvider = constantsProvider
+  }
+
+  @JvmName("methodWithoutArgs")
+  inline fun function(
+    name: String,
+    crossinline body: () -> Any?
+  ) {
+    methods[name] = Method(name, arrayOf()) { body() }
+  }
+
+  inline fun <reified R> function(
+    name: String,
+    crossinline body: () -> R
+  ) {
+    methods[name] = Method(name, arrayOf()) { 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) }
+    } else {
+      Method(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }
+    }
+  }
+
+  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) }
+    } else {
+      Method(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> 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) }
+    } 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) }
+    }
+  }
+
+  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) }
+    } 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) }
+    }
+  }
+
+  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) }
+    } 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) }
+    }
+  }
+
+  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) }
+    } 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) }
+    }
+  }
+
+  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) }
+    } 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) }
+    }
+  }
+
+  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) }
+    } 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) }
+    }
+  }
+
+  inline fun viewManager(body: ViewManagerDefinitionBuilder.() -> Unit) {
+    require(viewManagerDefinition == null) { "The module definition may have exported only one view manager." }
+
+    val viewManagerDefinitionBuilder = ViewManagerDefinitionBuilder()
+    body.invoke(viewManagerDefinitionBuilder)
+    viewManagerDefinition = viewManagerDefinitionBuilder.build()
+  }
+
+  inline fun onCreate(crossinline body: () -> Unit) {
+    eventListeners[EventName.MODULE_CREATE] = BasicEventListener(EventName.MODULE_CREATE) { body() }
+  }
+
+  inline fun onDestroy(crossinline body: () -> Unit) {
+    eventListeners[EventName.MODULE_DESTROY] = BasicEventListener(EventName.MODULE_DESTROY) { body() }
+  }
+
+  inline fun onActivityEntersForeground(crossinline body: () -> Unit) {
+    eventListeners[EventName.ACTIVITY_ENTERS_FOREGROUND] = BasicEventListener(EventName.ACTIVITY_ENTERS_FOREGROUND) { body() }
+  }
+
+  inline fun onActivityEntersBackground(crossinline body: () -> Unit) {
+    eventListeners[EventName.ACTIVITY_ENTERS_BACKGROUND] = BasicEventListener(EventName.ACTIVITY_ENTERS_BACKGROUND) { body() }
+  }
+
+  inline fun onActivityDestroys(crossinline body: () -> Unit) {
+    eventListeners[EventName.ACTIVITY_DESTROYS] = BasicEventListener(EventName.ACTIVITY_DESTROYS) { body() }
+  }
+
+  /**
+   * Defines event names that this module can send to JavaScript.
+   */
+  fun events(vararg events: String) {
+    eventsDefinition = EventsDefinition(events)
+  }
+
+  /**
+   * Method that is invoked when 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.
+   */
+  inline fun onStopObserving(crossinline body: () -> Unit) {
+    function("stopObserving", body)
+  }
+
+  inline fun onNewIntent(crossinline body: (Intent) -> Unit) {
+    eventListeners[EventName.ON_NEW_INTENT] = EventListenerWithPayload<Intent>(EventName.ON_NEW_INTENT) { body(it) }
+  }
+
+  inline fun onActivityResult(crossinline body: (Activity, OnActivityResultPayload) -> Unit) {
+    eventListeners[EventName.ON_ACTIVITY_RESULT] =
+      EventListenerWithSenderAndPayload<Activity, OnActivityResultPayload>(EventName.ON_ACTIVITY_RESULT) { sender, payload -> body(sender, payload) }
+  }
+}

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

@@ -0,0 +1,16 @@
+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.views.ViewManagerDefinition
+
+class ModuleDefinitionData(
+  val name: String,
+  val constantsProvider: () -> Map<String, Any?>,
+  val methods: Map<String, AnyMethod>,
+  val viewManagerDefinition: ViewManagerDefinition? = null,
+  val eventListeners: Map<EventName, EventListener> = emptyMap(),
+  val eventsDefinition: EventsDefinition? = null
+)

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

@@ -0,0 +1,5 @@
+package expo.modules.kotlin.records
+
+@Target(AnnotationTarget.PROPERTY)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class Field(val key: String = "")

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

@@ -0,0 +1,3 @@
+package expo.modules.kotlin.records
+
+interface Record

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

@@ -0,0 +1,55 @@
+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.types.TypeConverter
+import expo.modules.kotlin.types.TypeConverterProvider
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+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()
+
+  override fun convertNonOptional(value: Dynamic): T {
+    val jsMap = value.asMap()
+
+    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
+
+        if (!jsMap.hasKey(jsKey)) {
+          // TODO(@lukmccall): handle required keys
+          return@map
+        }
+
+        val value = jsMap.getDynamic(jsKey)
+        val javaField = property.javaField!!
+
+        val elementConverter = converterProvider.obtainTypeConverter(property.returnType)
+        val casted = elementConverter.convert(value)
+
+        javaField.isAccessible = true
+        javaField.set(instance, casted)
+      }
+
+    @Suppress("UNCHECKED_CAST")
+    return instance as T
+  }
+
+  private fun <T> getObjectConstructor(clazz: Class<T>): ObjectConstructor<T> {
+    return objectConstructorFactory.get(clazz)
+  }
+}

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

@@ -0,0 +1,14 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+import kotlin.reflect.KType
+
+fun KType.toAnyType(): AnyType = AnyType(this)
+
+class AnyType(val kType: KType) {
+  private val converter: TypeConverter<*> by lazy {
+    TypeConverterProviderImpl.obtainTypeConverter(kType)
+  }
+
+  fun convert(value: Dynamic): Any? = converter.convert(value)
+}

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

@@ -0,0 +1,44 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+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 arrayElementConverter = converterProvider.obtainTypeConverter(
+    requireNotNull(type.arguments.first().type) {
+      "The array type should contain the type of the elements."
+    }
+  )
+
+  override fun convertNonOptional(value: Dynamic): Array<*> {
+    val jsArray = value.asArray()
+    val array = createTypedArray(jsArray.size())
+    for (i in 0 until jsArray.size()) {
+      array[i] = jsArray
+        .getDynamic(i)
+        .recycle {
+          arrayElementConverter.convert(this)
+        }
+    }
+    return array
+  }
+
+  /**
+   * We can't use a Array<Any?> here. We have to create a typed array.
+   * Otherwise, cast which is done before calling lambda provided by the user will always fail.
+   * For JVM, Array<String> is a different type than Array<Any?>.
+   * The first one is translated to `[Ljava.lang.String;` but the second one is translated to `[java.lang.Object;`.
+   */
+  @Suppress("UNCHECKED_CAST")
+  private fun createTypedArray(size: Int): Array<Any?> {
+    return java.lang.reflect.Array.newInstance(
+      (type.arguments.first().type!!.classifier as KClass<*>).java,
+      size
+    ) as Array<Any?>
+  }
+}

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

@@ -0,0 +1,60 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+class IntTypeConverter(isOptional: Boolean) : TypeConverter<Int>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): Int = value.asInt()
+}
+
+class DoubleTypeConverter(isOptional: Boolean) : TypeConverter<Double>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): Double = value.asDouble()
+}
+
+class FloatTypeConverter(isOptional: Boolean) : TypeConverter<Float>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): Float = value.asDouble().toFloat()
+}
+
+class BoolTypeConverter(isOptional: Boolean) : TypeConverter<Boolean>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): Boolean = value.asBoolean()
+}
+
+class StringTypeConverter(isOptional: Boolean) : TypeConverter<String>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): String = value.asString()
+}
+
+class ReadableArrayTypeConverter(isOptional: Boolean) : TypeConverter<ReadableArray>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): ReadableArray = value.asArray()
+}
+
+class ReadableMapTypeConverter(isOptional: Boolean) : TypeConverter<ReadableMap>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): ReadableMap = value.asMap()
+}
+
+class PrimitiveIntArrayTypeConverter(isOptional: Boolean) : TypeConverter<IntArray>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): IntArray {
+    val jsArray = value.asArray()
+    return IntArray(jsArray.size()) { index ->
+      jsArray.getInt(index)
+    }
+  }
+}
+
+class PrimitiveDoubleArrayTypeConverter(isOptional: Boolean) : TypeConverter<DoubleArray>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): DoubleArray {
+    val jsArray = value.asArray()
+    return DoubleArray(jsArray.size()) { index ->
+      jsArray.getDouble(index)
+    }
+  }
+}
+
+class PrimitiveFloatArrayTypeConverter(isOptional: Boolean) : TypeConverter<FloatArray>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): FloatArray {
+    val jsArray = value.asArray()
+    return FloatArray(jsArray.size()) { index ->
+      jsArray.getDouble(index).toFloat()
+    }
+  }
+}

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

@@ -0,0 +1,84 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.exception.IncompatibleArgTypeException
+import expo.modules.kotlin.toKType
+import kotlin.reflect.KClass
+import kotlin.reflect.full.createType
+import kotlin.reflect.full.declaredMemberProperties
+import kotlin.reflect.full.primaryConstructor
+
+class EnumTypeConverter(
+  private val enumClass: KClass<Enum<*>>,
+  isOptional: Boolean
+) : TypeConverter<Enum<*>>(isOptional) {
+  override fun convertNonOptional(value: Dynamic): Enum<*> {
+    @Suppress("UNCHECKED_CAST")
+    val enumConstants = requireNotNull(enumClass.java.enumConstants) {
+      "Passed type is not an enum type."
+    }
+    require(enumConstants.isNotEmpty()) {
+      "Passed enum type is empty."
+    }
+
+    val primaryConstructor = requireNotNull(enumClass.primaryConstructor) {
+      "Cannot convert js value to enum without the primary constructor."
+    }
+
+    if (primaryConstructor.parameters.isEmpty()) {
+      return convertEnumWithoutParameter(value, enumConstants)
+    } else if (primaryConstructor.parameters.size == 1) {
+      return convertEnumWithParameter(
+        value,
+        enumConstants,
+        primaryConstructor.parameters.first().name!!
+      )
+    }
+
+    throw IncompatibleArgTypeException(value.type.toKType(), enumClass.createType())
+  }
+
+  /**
+   * If the primary constructor doesn't take any parameters, we treat the name of each enum as a value.
+   * So the jsValue has to contain string.
+   */
+  private fun convertEnumWithoutParameter(
+    jsValue: Dynamic,
+    enumConstants: Array<out Enum<*>>
+  ): Enum<*> {
+    val unwrappedJsValue = jsValue.asString()
+    return requireNotNull(
+      enumConstants.find { it.name == unwrappedJsValue }
+    ) { "Couldn't convert ${jsValue.asString()} to ${enumClass.simpleName}." }
+  }
+
+  /**
+   * If the primary constructor take one parameter, we treat this parameter as a enum value.
+   * In that case, we handles two different types: Int and String.
+   */
+  private fun convertEnumWithParameter(
+    jsValue: Dynamic,
+    enumConstants: Array<out Enum<*>>,
+    parameterName: String
+  ): Enum<*> {
+    // To obtain the value of parameter, we have to find a property that is connected with this parameter.
+    @Suppress("UNCHECKED_CAST")
+    val parameterProperty = enumClass
+      .declaredMemberProperties
+      .find { it.name == parameterName }
+    requireNotNull(parameterProperty) { "Cannot find a property for $parameterName parameter." }
+
+    val parameterType = parameterProperty.returnType.classifier
+    val jsUnwrapValue = if (parameterType == String::class) {
+      jsValue.asString()
+    } else {
+      jsValue.asInt()
+    }
+
+    return requireNotNull(
+      enumConstants.find {
+        parameterProperty.get(it) == jsUnwrapValue
+      }
+    ) { "Couldn't convert ${jsValue.asString()} to ${enumClass.simpleName} where $parameterName is the enum parameter. " }
+  }
+}

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

@@ -0,0 +1,25 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+import expo.modules.kotlin.recycle
+import kotlin.reflect.KType
+
+class ListTypeConverter(
+  converterProvider: TypeConverterProvider,
+  type: KType,
+) : TypeConverter<List<*>>(type.isMarkedNullable) {
+  private val elementConverter = converterProvider.obtainTypeConverter(
+    requireNotNull(type.arguments.first().type) {
+      "The list type should contain the type of elements."
+    }
+  )
+
+  override fun convertNonOptional(value: Dynamic): List<*> {
+    val jsArray = value.asArray()
+    return List(jsArray.size()) { index ->
+      jsArray.getDynamic(index).recycle {
+        elementConverter.convert(this)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,39 @@
+@file:OptIn(ExperimentalStdlibApi::class)
+
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.DynamicFromObject
+import expo.modules.kotlin.recycle
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class MapTypeConverter(
+  converterProvider: TypeConverterProvider,
+  type: KType
+) : TypeConverter<Map<*, *>>(type.isMarkedNullable) {
+  init {
+    require(type.arguments.first().type == typeOf<String>()) {
+      "The map key type should be String, but received ${type.arguments.first()}."
+    }
+  }
+
+  private val valueConverter = converterProvider.obtainTypeConverter(
+    requireNotNull(type.arguments.getOrNull(1)?.type) {
+      "The map type should contain the key type."
+    }
+  )
+
+  override fun convertNonOptional(value: Dynamic): Map<*, *> {
+    val jsMap = value.asMap()
+    val result = mutableMapOf<String, Any?>()
+
+    jsMap.entryIterator.forEach { (key, value) ->
+      DynamicFromObject(value).recycle {
+        result[key] = valueConverter.convert(this)
+      }
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,28 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+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."
+    }
+  )
+
+  override fun convertNonOptional(value: Dynamic): Pair<*, *> {
+    val jsArray = value.asArray()
+    return Pair(
+      firstConverter.convert(jsArray.getDynamic(0)),
+      secondConverter.convert(jsArray.getDynamic(1)),
+    )
+  }
+}

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

@@ -0,0 +1,19 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+
+abstract class TypeConverter<Type : Any>(
+  private val isOptional: Boolean
+) {
+  open fun convert(value: Dynamic): Type? {
+    if (value.isNull) {
+      if (isOptional) {
+        return null
+      }
+      throw IllegalArgumentException()
+    }
+    return convertNonOptional(value)
+  }
+
+  abstract fun convertNonOptional(value: Dynamic): Type
+}