expo-modules-core 0.4.6 → 0.6.0

package/android/src/main/java/expo/modules/kotlin/events/KEventEmitterWrapper.kt

@@ -0,0 +1,26 @@
+package expo.modules.kotlin.events
+
+import android.os.Bundle
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.kotlin.ModuleHolder
+
+/**
+ * In Swift, we check if the event is supported. Otherwise, we can't send such event through the bridge.
+ * However, in Kotlin this is unnecessary, but to make our API consistent, we added similar check.
+ * But because of that, we had to create a wrapper for EventEmitter.
+ */
+class KEventEmitterWrapper(
+  private val moduleHolder: ModuleHolder,
+  private val legacyEventEmitter: EventEmitter
+) : EventEmitter by legacyEventEmitter {
+  override fun emit(eventName: String, eventBody: Bundle?) {
+    require(
+      moduleHolder
+        .definition
+        .eventsDefinition
+        ?.names
+        ?.contains(eventName) == true
+    ) { "Unsupported event: $eventName." }
+    legacyEventEmitter.emit(eventName, eventBody)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/events/OnActivityResultPayload.kt

@@ -0,0 +1,8 @@
+package expo.modules.kotlin.events
+
+import android.content.Intent
+
+/**
+ * Payload for the `onActivityResult` event.
+ */
+data class OnActivityResultPayload(val requestCode: Int, val resultCode: Int, val data: Intent?)

package/android/src/main/java/expo/modules/kotlin/exception/CodedException.kt

@@ -0,0 +1,70 @@
+package expo.modules.kotlin.exception
+
+import java.util.*
+import kotlin.reflect.KType
+
+/**
+ * A class for errors specifying its `code` and providing the `description`.
+ */
+open class CodedException(
+  message: String?,
+  cause: Throwable?
+) : Exception(message, cause) {
+  // We need that secondary property, cause we can't access
+  // the javaClass property in the constructor.
+  private var providedCode: String? = null
+
+  val code
+    get() = providedCode ?: inferCode(javaClass)
+
+  constructor(code: String, message: String, cause: Throwable?) : this(message, cause) {
+    providedCode = code
+  }
+
+  constructor(message: String) : this(message, null)
+
+  constructor(cause: Throwable) : this(cause.localizedMessage, cause)
+
+  constructor() : this(null, null)
+
+  companion object {
+    /**
+     * The code is inferred from the class name — e.g. the code of `ModuleNotFoundException` becomes `ERR_MODULE_NOT_FOUND`.
+     */
+    private fun inferCode(clazz: Class<*>): String {
+      val name = requireNotNull(clazz.simpleName) { "Cannot infer code name from class name. We don't support anonymous classes." }
+
+      return "ERR_" + name
+        .replace("(Exception)$".toRegex(), "")
+        .replace("(.)([A-Z])".toRegex(), "$1_$2")
+        .toUpperCase(Locale.ROOT)
+    }
+  }
+}
+
+internal class IncompatibleArgTypeException(
+  argumentType: KType,
+  desiredType: KType,
+  cause: Throwable? = null
+) : CodedException(
+  message = "Argument type $argumentType is not compatible with expected type $desiredType.",
+  cause = cause
+)
+
+internal class MissingTypeConverter(
+  forType: KType
+) : CodedException(
+  message = "Cannot find type converter for $forType.",
+)
+
+internal class InvalidArgsNumberException(received: Int, expected: Int) :
+  CodedException(message = "Received $received arguments, but $expected was expected.")
+
+internal class MethodNotFoundException(methodName: String, moduleName: String) :
+  CodedException(message = "Cannot fund method $methodName in module $moduleName")
+
+internal class NullArgumentException(desiredType: KType) :
+  CodedException(message = "Cannot assigned null to not nullable type $desiredType")
+
+internal class UnexpectedException(val throwable: Throwable) :
+  CodedException(throwable)

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

@@ -0,0 +1,50 @@
+package expo.modules.kotlin.methods
+
+import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.InvalidArgsNumberException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.iterator
+import expo.modules.kotlin.recycle
+import expo.modules.kotlin.types.AnyType
+import kotlin.jvm.Throws
+
+abstract class AnyMethod(
+  protected val name: String,
+  private val desiredArgsTypes: Array<AnyType>
+) {
+  fun call(args: ReadableArray, promise: Promise) {
+    if (desiredArgsTypes.size != args.size()) {
+      promise.reject(InvalidArgsNumberException(args.size(), desiredArgsTypes.size))
+      return
+    }
+    try {
+      val convertedArgs = convertArgs(args)
+      callImplementation(convertedArgs, promise)
+    } catch (codedError: CodedException) {
+      promise.reject(codedError)
+    } catch (e: Throwable) {
+      promise.reject(UnexpectedException(e))
+    }
+  }
+
+  @Throws(CodedException::class)
+  internal abstract fun callImplementation(args: Array<out Any?>, promise: Promise)
+
+  val argsCount get() = desiredArgsTypes.size
+
+  @Throws(CodedException::class)
+  private fun convertArgs(args: ReadableArray): Array<out Any?> {
+    val finalArgs = Array<Any?>(desiredArgsTypes.size) { null }
+    val argIterator = args.iterator()
+    desiredArgsTypes
+      .withIndex()
+      .forEach { (index, type) ->
+        argIterator.next().recycle {
+          finalArgs[index] = type.convert(this)
+        }
+      }
+    return finalArgs
+  }
+}

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

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

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