expo-modules-core 0.9.2 → 0.11.1

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

@@ -1,16 +1,41 @@
 package expo.modules.kotlin.modules
 
+import expo.modules.kotlin.ConcatIterator
+import expo.modules.kotlin.ModuleHolder
 import expo.modules.kotlin.events.EventListener
 import expo.modules.kotlin.events.EventName
-import expo.modules.kotlin.events.EventsDefinition
-import expo.modules.kotlin.functions.AnyFunction
+import expo.modules.kotlin.objects.ObjectDefinitionData
 import expo.modules.kotlin.views.ViewManagerDefinition
 
+/**
+ * Intermediate data used to create a proper [ProcessedModuleDefinition].
+ * It contains all, unprocessed data from [ModuleDefinitionBuilder].
+ */
 class ModuleDefinitionData(
   val name: String,
-  val constantsProvider: () -> Map<String, Any?>,
-  val methods: Map<String, AnyFunction>,
+  val objectDefinition: ObjectDefinitionData,
   val viewManagerDefinition: ViewManagerDefinition? = null,
   val eventListeners: Map<EventName, EventListener> = emptyMap(),
-  val eventsDefinition: EventsDefinition? = null
 )
+
+/**
+ * A final version of the ModuleDefinition.
+ * Most values are just copied from [ModuleDefinitionData].
+ * However some fields like `asyncFunctions` need to be processed or bound with the [ModuleHolder].
+ */
+class ProcessedModuleDefinition(
+  data: ModuleDefinitionData,
+  moduleHolder: ModuleHolder
+) {
+  val name = data.name
+  val constantsProvider = data.objectDefinition.constantsProvider
+  val syncFunctions = data.objectDefinition.syncFunctions
+  val asyncFunctions = data.objectDefinition.asyncFunctions + data.objectDefinition.buildSuspendFunctions(moduleHolder)
+  val viewManagerDefinition = data.viewManagerDefinition
+  val eventListeners = data.eventListeners
+  val eventsDefinition = data.objectDefinition.eventsDefinition
+  val properties = data.objectDefinition.properties
+
+  val functions
+    get() = ConcatIterator(syncFunctions.values.iterator(), asyncFunctions.values.iterator())
+}

package/android/src/main/java/expo/modules/kotlin/objects/ObjectDefinitionBuilder.kt

@@ -0,0 +1,271 @@
+/**
+ * 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)
+@file:Suppress("FunctionName")
+
+package expo.modules.kotlin.objects
+
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.events.EventsDefinition
+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.SyncFunctionComponent
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.typeOf
+
+/**
+ * Base class for other definitions representing an object, such as `ModuleDefinition`.
+ */
+open class ObjectDefinitionBuilder {
+  private var constantsProvider = { emptyMap<String, Any?>() }
+  private var eventsDefinition: EventsDefinition? = null
+
+  @PublishedApi
+  internal var syncFunctions = mutableMapOf<String, SyncFunctionComponent>()
+
+  @PublishedApi
+  internal var asyncFunctions = mutableMapOf<String, AsyncFunction>()
+
+  private var functionBuilders = mutableMapOf<String, AsyncFunctionBuilder>()
+
+  @PublishedApi
+  internal var properties = mutableMapOf<String, PropertyComponentBuilder>()
+
+  fun buildObject(): ObjectDefinitionData {
+    return ObjectDefinitionData(
+      constantsProvider,
+      syncFunctions,
+      asyncFunctions,
+      functionBuilders.mapValues { (_, value) -> value.build() },
+      eventsDefinition,
+      properties.mapValues { (_, value) -> value.build() }
+    )
+  }
+
+  /**
+   * 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("FunctionWithoutArgs")
+  inline fun Function(
+    name: String,
+    crossinline body: () -> Any?
+  ) {
+    SyncFunctionComponent(name, arrayOf()) { body() }.also {
+      syncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R> Function(
+    name: String,
+    crossinline body: () -> R
+  ) {
+    SyncFunctionComponent(name, arrayOf()) { body() }.also {
+      syncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R, reified P0> Function(
+    name: String,
+    crossinline body: (p0: P0) -> R
+  ) {
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }.also {
+      syncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1> Function(
+    name: String,
+    crossinline body: (p0: P0, p1: P1) -> R
+  ) {
+    SyncFunctionComponent(name, arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }.also {
+      syncFunctions[name] = it
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2> Function(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2) -> R
+  ) {
+    SyncFunctionComponent(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 {
+      syncFunctions[name] = it
+    }
+  }
+
+  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
+  ) {
+    SyncFunctionComponent(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 {
+      syncFunctions[name] = it
+    }
+  }
+
+  @JvmName("AsyncFunctionWithoutArgs")
+  inline fun AsyncFunction(
+    name: String,
+    crossinline body: () -> Any?
+  ) {
+    asyncFunctions[name] = AsyncFunctionComponent(name, arrayOf()) { body() }
+  }
+
+  inline fun <reified R> AsyncFunction(
+    name: String,
+    crossinline body: () -> R
+  ) {
+    asyncFunctions[name] = AsyncFunctionComponent(name, arrayOf()) { body() }
+  }
+
+  inline fun <reified R, reified P0> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0) -> R
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1) -> R
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2> AsyncFunction(
+    name: String,
+    crossinline body: (p0: P0, p1: P1, p2: P2) -> R
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  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
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  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
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  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
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  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
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  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
+  ) {
+    asyncFunctions[name] = 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) }
+    }
+  }
+
+  fun AsyncFunction(
+    name: String
+  ) = AsyncFunctionBuilder(name).also { functionBuilders[name] = it }
+
+  /**
+   * Defines event names that this module can send to JavaScript.
+   */
+  fun Events(vararg events: String) {
+    eventsDefinition = EventsDefinition(events)
+  }
+
+  /**
+   * Creates module's lifecycle listener that is called right after the first event listener is added.
+   */
+  inline fun OnStartObserving(crossinline body: () -> Unit) {
+    AsyncFunction("startObserving", body)
+  }
+
+  /**
+   * Creates module's lifecycle listener that is called right after all event listeners are removed.
+   */
+  inline fun OnStopObserving(crossinline body: () -> Unit) {
+    AsyncFunction("stopObserving", body)
+  }
+
+  /**
+   * Creates the property with given name. The component is basically no-op if you don't call `.get()` or `.set()` on it.
+   */
+  fun Property(name: String): PropertyComponentBuilder {
+    return PropertyComponentBuilder(name).also {
+      properties[name] = it
+    }
+  }
+
+  /**
+   * Creates the read-only property whose getter doesn't take the caller as an argument.
+   */
+  inline fun <T> Property(name: String, crossinline body: () -> T): PropertyComponentBuilder {
+    return PropertyComponentBuilder(name).also {
+      it.get(body)
+      properties[name] = it
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/objects/ObjectDefinitionData.kt

@@ -0,0 +1,21 @@
+package expo.modules.kotlin.objects
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.events.EventsDefinition
+import expo.modules.kotlin.functions.AsyncFunction
+import expo.modules.kotlin.functions.SuspendFunctionComponent
+import expo.modules.kotlin.functions.SuspendFunctionComponentBuilder
+import expo.modules.kotlin.functions.SyncFunctionComponent
+
+class ObjectDefinitionData(
+  val constantsProvider: () -> Map<String, Any?>,
+  val syncFunctions: Map<String, SyncFunctionComponent>,
+  val asyncFunctions: Map<String, AsyncFunction>,
+  val suspendFunctionBuilders: Map<String, SuspendFunctionComponentBuilder>,
+  val eventsDefinition: EventsDefinition?,
+  val properties: Map<String, PropertyComponent>
+) {
+  fun buildSuspendFunctions(moduleHolder: ModuleHolder): Map<String, SuspendFunctionComponent> {
+    return suspendFunctionBuilders.mapValues { (_, value) -> value.build(moduleHolder) }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/objects/PropertyComponent.kt

@@ -0,0 +1,54 @@
+package expo.modules.kotlin.objects
+
+import com.facebook.react.bridge.Arguments
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.jni.CppType
+import expo.modules.kotlin.jni.JNIFunctionBody
+import expo.modules.kotlin.jni.JavaScriptModuleObject
+
+class PropertyComponent(
+  /**
+   * Name of the property.
+   */
+  val name: String,
+
+  /**
+   * Synchronous function that is called when the property is being accessed.
+   */
+  val getter: SyncFunctionComponent? = null,
+
+  /**
+   * Synchronous function that is called when the property is being set.
+   */
+  val setter: SyncFunctionComponent? = null
+) {
+  /**
+   * Attaches property to the provided js object.
+   */
+  fun attachToJSObject(jsObject: JavaScriptModuleObject) {
+    val jniGetter = if (getter != null) {
+      JNIFunctionBody {
+        val result = getter.call(emptyArray())
+        return@JNIFunctionBody Arguments.fromJavaArgs(arrayOf(result))
+      }
+    } else {
+      null
+    }
+
+    val jniSetter = if (setter != null) {
+      JNIFunctionBody { args ->
+        setter.call(args)
+        return@JNIFunctionBody null
+      }
+    } else {
+      null
+    }
+
+    jsObject.registerProperty(
+      name,
+      setter?.getCppRequiredTypes()?.first() ?: CppType.NONE.value,
+      jniGetter,
+      jniSetter
+    )
+  }
+}

package/android/src/main/java/expo/modules/kotlin/objects/PropertyComponentBuilder.kt

@@ -0,0 +1,32 @@
+@file:OptIn(ExperimentalStdlibApi::class)
+
+package expo.modules.kotlin.objects
+
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.typeOf
+
+class PropertyComponentBuilder(
+  val name: String
+) {
+  var getter: SyncFunctionComponent? = null
+  var setter: SyncFunctionComponent? = null
+
+  /**
+   * Modifier that sets property getter that has no arguments (the caller is not used).
+   */
+  inline fun <T> get(crossinline body: () -> T) = apply {
+    getter = SyncFunctionComponent("get", arrayOf()) { body() }
+  }
+
+  /**
+   * Modifier that sets property setter that receives only the new value as an argument.
+   */
+  inline fun <reified T> set(crossinline body: (newValue: T) -> Unit) = apply {
+    setter = SyncFunctionComponent("set", arrayOf(typeOf<T>().toAnyType())) { body(it[0] as T) }
+  }
+
+  fun build(): PropertyComponent {
+    return PropertyComponent(name, getter, setter)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/providers/AppContextProvider.kt

@@ -0,0 +1,14 @@
+package expo.modules.kotlin.providers
+
+import expo.modules.kotlin.AppContext
+
+/**
+ * Provider that allows accessing [AppContext] and all it's public parts (e.g. [AppContext.reactContext]).
+ */
+interface AppContextProvider {
+  /**
+   * [AppContext] reference. If it's not possible to access the [AppContext], because it's null
+   * then it's an invalid situation and should result in throwing descriptive error.
+   */
+  val appContext: AppContext
+}

package/android/src/main/java/expo/modules/kotlin/providers/CurrentActivityProvider.kt

@@ -0,0 +1,22 @@
+package expo.modules.kotlin.providers
+
+import com.facebook.react.ReactActivity
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.FragmentActivity
+import androidx.core.app.ComponentActivity
+import android.app.Activity
+
+/**
+ * A class that provides the accessor to the [ReactActivity]. It enables accessing
+ * AndroidX/Android Jetpack features in Expo libraries coming from all subclassing chain:
+ * [AppCompatActivity], [FragmentActivity], [ComponentActivity], [Activity]
+*/
+interface CurrentActivityProvider {
+  /**
+   * Returns the current [Activity] that should be an instance of [AppCompatActivity].
+   * This activity is most likely an instance of [ReactActivity], but it's been decided not to expose
+   * `react-native` symbols via `expo-module-core` public API.
+   * @returns null if the [Activity] is not yet available (eg. Application has not yet fully started)
+   */
+  val currentActivity: AppCompatActivity?
+}

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

@@ -1,13 +1,16 @@
 package expo.modules.kotlin.records
 
 import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableMap
 import expo.modules.kotlin.allocators.ObjectConstructor
 import expo.modules.kotlin.allocators.ObjectConstructorFactory
 import expo.modules.kotlin.exception.FieldCastException
 import expo.modules.kotlin.exception.FieldRequiredException
 import expo.modules.kotlin.exception.RecordCastException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.CppType
 import expo.modules.kotlin.recycle
+import expo.modules.kotlin.types.DynamicAwareTypeConverters
 import expo.modules.kotlin.types.TypeConverter
 import expo.modules.kotlin.types.TypeConverterProvider
 import kotlin.reflect.KClass
@@ -21,7 +24,7 @@ import kotlin.reflect.jvm.javaField
 class RecordTypeConverter<T : Record>(
   private val converterProvider: TypeConverterProvider,
   val type: KType,
-) : TypeConverter<T>(type.isMarkedNullable) {
+) : DynamicAwareTypeConverters<T>(type.isMarkedNullable) {
   private val objectConstructorFactory = ObjectConstructorFactory()
   private val propertyDescriptors: Map<KProperty1<out Any, *>, PropertyDescriptor> =
     (type.classifier as KClass<*>)
@@ -40,9 +43,23 @@ class RecordTypeConverter<T : Record>(
       .filterNotNull()
       .toMap()
 
-  override fun convertNonOptional(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
+  override fun convertFromDynamic(value: Dynamic): T = exceptionDecorator({ cause -> RecordCastException(type, cause) }) {
     val jsMap = value.asMap()
+    return convertFromReadableMap(jsMap)
+  }
+
+  override fun convertFromAny(value: Any): T {
+    if (value is ReadableMap) {
+      return convertFromReadableMap(value)
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    return value as T
+  }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_MAP)
 
+  private fun convertFromReadableMap(jsMap: ReadableMap): T {
     val kClass = type.classifier as KClass<*>
     val instance = getObjectConstructor(kClass.java).construct()
 

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

@@ -1,6 +1,5 @@
 package expo.modules.kotlin.types
 
-import com.facebook.react.bridge.Dynamic
 import kotlin.reflect.KType
 
 fun KType.toAnyType(): AnyType = AnyType(this)
@@ -10,5 +9,7 @@ class AnyType(val kType: KType) {
     TypeConverterProviderImpl.obtainTypeConverter(kType)
   }
 
-  fun convert(value: Dynamic): Any? = converter.convert(value)
+  fun convert(value: Any?): Any? = converter.convert(value)
+
+  fun getCppRequiredTypes(): Int = converter.getCppRequiredTypes().fold(0) { acc, current -> acc or current.value }
 }

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

@@ -0,0 +1,36 @@
+package expo.modules.kotlin.types
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReadableType
+import expo.modules.kotlin.jni.CppType
+
+/**
+ * Type converter that handles conversion from [Any] or [Dynamic] to [Any].
+ * In the first case, it will just pass provided value.
+ * In case when it receives [Dynamic], it will unpack the provided value.
+ * In that way, we produce the same output for JSI and bridge implementation.
+ */
+class AnyTypeConverter(isOptional: Boolean) : DynamicAwareTypeConverters<Any>(isOptional) {
+  override fun convertFromDynamic(value: Dynamic): Any {
+    return when (value.type) {
+      ReadableType.Boolean -> value.asBoolean()
+      ReadableType.Number -> value.asDouble()
+      ReadableType.String -> value.asString()
+      ReadableType.Map -> value.asMap()
+      ReadableType.Array -> value.asArray()
+      else -> error("Unknown dynamic type: ${value.type}")
+    }
+  }
+
+  override fun convertFromAny(value: Any): Any {
+    return value
+  }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(
+    CppType.READABLE_MAP,
+    CppType.READABLE_ARRAY,
+    CppType.STRING,
+    CppType.BOOLEAN,
+    CppType.DOUBLE
+  )
+}

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

@@ -3,6 +3,7 @@ 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.jni.CppType
 import expo.modules.kotlin.recycle
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
@@ -10,14 +11,14 @@ import kotlin.reflect.KType
 class ArrayTypeConverter(
   converterProvider: TypeConverterProvider,
   private val arrayType: KType,
-) : TypeConverter<Array<*>>(arrayType.isMarkedNullable) {
+) : DynamicAwareTypeConverters<Array<*>>(arrayType.isMarkedNullable) {
   private val arrayElementConverter = converterProvider.obtainTypeConverter(
     requireNotNull(arrayType.arguments.first().type) {
       "The array type should contain the type of the elements."
     }
   )
 
-  override fun convertNonOptional(value: Dynamic): Array<*> {
+  override fun convertFromDynamic(value: Dynamic): Array<*> {
     val jsArray = value.asArray()
     val array = createTypedArray(jsArray.size())
     for (i in 0 until jsArray.size()) {
@@ -34,6 +35,8 @@ class ArrayTypeConverter(
     return array
   }
 
+  override fun convertFromAny(value: Any): Array<*> = value as 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.
@@ -47,4 +50,6 @@ class ArrayTypeConverter(
       size
     ) as Array<Any?>
   }
+
+  override fun getCppRequiredTypes(): List<CppType> = listOf(CppType.READABLE_ARRAY)
 }