expo-modules-core 1.2.6 → 1.3.0

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptModuleObject.kt

@@ -1,8 +1,11 @@
 package expo.modules.kotlin.jni
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.NativeMap
 import expo.modules.core.interfaces.DoNotStrip
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.objects.ObjectDefinitionData
 
 /**
  * A class to communicate with CPP part of the [expo.modules.kotlin.modules.Module] class.
@@ -13,13 +16,35 @@ import expo.modules.core.interfaces.DoNotStrip
  */
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
-class JavaScriptModuleObject(val name: String) {
+class JavaScriptModuleObject(val name: String) : Destructible {
   // Has to be called "mHybridData" - fbjni uses it via reflection
   @DoNotStrip
   private val mHybridData = initHybrid()
 
   private external fun initHybrid(): HybridData
 
+  init {
+    JNIDeallocator.addReference(this)
+  }
+
+  fun initUsingObjectDefinition(appContext: AppContext, definition: ObjectDefinitionData) = apply {
+    val constants = definition.constantsProvider()
+    val convertedConstants = Arguments.makeNativeMap(constants)
+    exportConstants(convertedConstants)
+
+    definition
+      .functions
+      .forEach { function ->
+        function.attachToJSObject(appContext, this)
+      }
+
+    definition
+      .properties
+      .forEach { (_, prop) ->
+        prop.attachToJSObject(this)
+      }
+  }
+
   /**
    * Exports constants
    */
@@ -29,18 +54,30 @@ class JavaScriptModuleObject(val name: String) {
    * Register a promise-less function on the CPP module representation.
    * After calling this function, user can access the exported function in the JS code.
    */
-  external fun registerSyncFunction(name: String, args: Int, desiredTypes: Array<ExpectedType>, body: JNIFunctionBody)
+  external fun registerSyncFunction(name: String, takesOwner: Boolean, args: Int, desiredTypes: Array<ExpectedType>, body: JNIFunctionBody)
 
   /**
    * Register a promise function on the CPP module representation.
    * After calling this function, user can access the exported function in the JS code.
    */
-  external fun registerAsyncFunction(name: String, args: Int, desiredTypes: Array<ExpectedType>, body: JNIAsyncFunctionBody)
+  external fun registerAsyncFunction(name: String, takesOwner: Boolean, args: Int, desiredTypes: Array<ExpectedType>, body: JNIAsyncFunctionBody)
 
   external fun registerProperty(name: String, desiredType: ExpectedType, getter: JNIFunctionBody?, setter: JNIFunctionBody?)
 
+  external fun registerClass(name: String, classModule: JavaScriptModuleObject, takesOwner: Boolean, args: Int, desiredTypes: Array<ExpectedType>, body: JNIFunctionBody)
+
+  external fun registerViewPrototype(viewPrototype: JavaScriptModuleObject)
+
   @Throws(Throwable::class)
   protected fun finalize() {
+    deallocate()
+  }
+
+  override fun deallocate() {
     mHybridData.resetNative()
   }
+
+  override fun toString(): String {
+    return "JavaScriptModuleObject_$name"
+  }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptObject.kt

@@ -9,7 +9,12 @@ import expo.modules.core.interfaces.DoNotStrip
  */
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
-open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) {
+open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
+  init {
+    @Suppress("LeakingThis")
+    JNIDeallocator.addReference(this)
+  }
+
   /**
    * The property descriptor options for the property being defined or modified.
    */
@@ -30,23 +35,34 @@ open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private
     Writable(1 shl 2),
   }
 
+  fun isValid() = mHybridData.isValid
+
   external fun hasProperty(name: String): Boolean
   external fun getProperty(name: String): JavaScriptValue
-  external fun getPropertyNames(): Array<String>
 
+  external fun getPropertyNames(): Array<String>
   private external fun setBoolProperty(name: String, value: Boolean)
   private external fun setDoubleProperty(name: String, value: Double)
   private external fun setStringProperty(name: String, value: String?)
   private external fun setJSValueProperty(name: String, value: JavaScriptValue?)
   private external fun setJSObjectProperty(name: String, value: JavaScriptObject?)
-  private external fun unsetProperty(name: String)
 
+  private external fun unsetProperty(name: String)
   private external fun defineBoolProperty(name: String, value: Boolean, options: Int)
   private external fun defineDoubleProperty(name: String, value: Double, options: Int)
   private external fun defineStringProperty(name: String, value: String?, options: Int)
   private external fun defineJSValueProperty(name: String, value: JavaScriptValue?, options: Int)
+
   private external fun defineJSObjectProperty(name: String, value: JavaScriptObject?, options: Int)
 
+  private external fun defineNativeDeallocator(deallocator: JNIFunctionBody)
+
+  internal fun defineDeallocator(deallocator: () -> Unit) {
+    defineNativeDeallocator {
+      deallocator()
+    }
+  }
+
   fun setProperty(name: String, value: Boolean) = setBoolProperty(name, value)
   fun setProperty(name: String, value: Int) = setDoubleProperty(name, value.toDouble())
   fun setProperty(name: String, value: Double) = setDoubleProperty(name, value)
@@ -103,6 +119,10 @@ open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private
 
   @Throws(Throwable::class)
   protected fun finalize() {
+    deallocate()
+  }
+
+  override fun deallocate() {
     mHybridData.resetNative()
   }
 }

package/android/src/main/java/expo/modules/kotlin/jni/JavaScriptValue.kt

@@ -2,6 +2,7 @@ package expo.modules.kotlin.jni
 
 import com.facebook.jni.HybridData
 import expo.modules.core.interfaces.DoNotStrip
+import kotlin.reflect.typeOf
 
 /**
  * A Kotlin representation of jsi::Value.
@@ -9,7 +10,12 @@ import expo.modules.core.interfaces.DoNotStrip
  */
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
-class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) {
+class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
+  init {
+    JNIDeallocator.addReference(this)
+  }
+
+  fun isValid() = mHybridData.isValid
   external fun kind(): String
 
   external fun isNull(): Boolean
@@ -30,12 +36,31 @@ class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mH
   external fun getArray(): Array<JavaScriptValue>
   external fun getTypedArray(): JavaScriptTypedArray
 
+  private external fun <T : Any?> jniGetFunction(): JavaScriptFunction<T>
+  @PublishedApi
+  internal fun <T : Any?> internalJniGetFunction(): JavaScriptFunction<T> = jniGetFunction()
+  inline fun <reified ReturnType : Any?> getFunction(): JavaScriptFunction<ReturnType> {
+    return internalJniGetFunction<ReturnType>().apply {
+      returnType = typeOf<ReturnType>()
+    }
+  }
+  @JvmName("getVoidFunction")
+  fun getFunction(): JavaScriptFunction<Unit> {
+    return internalJniGetFunction<Unit>().apply {
+      returnType = typeOf<Unit>()
+    }
+  }
+
   fun getInt() = getDouble().toInt()
   fun getLong() = getDouble().toLong()
   fun getFloat() = getDouble().toFloat()
 
   @Throws(Throwable::class)
   protected fun finalize() {
+    deallocate()
+  }
+
+  override fun deallocate() {
     mHybridData.resetNative()
   }
 }

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

@@ -1,11 +1,9 @@
 package expo.modules.kotlin.modules
 
 import android.os.Bundle
-import expo.modules.core.errors.ModuleDestroyedException
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.providers.AppContextProvider
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.cancel
 
 abstract class Module : AppContextProvider {
 
@@ -25,9 +23,6 @@ abstract class Module : AppContextProvider {
   @PublishedApi
   internal lateinit var coroutineScopeDelegate: Lazy<CoroutineScope>
 
-  @Deprecated(message = "Use a scope from the AppContext", replaceWith = ReplaceWith("appContext.modulesQueue"))
-  val coroutineScope get() = coroutineScopeDelegate.value
-
   fun sendEvent(name: String, body: Bundle? = Bundle.EMPTY) {
     moduleEventEmitter?.emit(name, body)
   }
@@ -37,12 +32,6 @@ abstract class Module : AppContextProvider {
   }
 
   abstract fun definition(): ModuleDefinitionData
-
-  internal fun cleanUp() {
-    if (coroutineScopeDelegate.isInitialized()) {
-      coroutineScope.cancel(ModuleDestroyedException())
-    }
-  }
 }
 
 @Suppress("FunctionName")

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

@@ -6,6 +6,8 @@ import android.app.Activity
 import android.content.Intent
 import android.view.View
 import expo.modules.kotlin.activityresult.AppContextActivityResultCaller
+import expo.modules.kotlin.classcomponent.ClassComponentBuilder
+import expo.modules.kotlin.classcomponent.ClassDefinitionData
 import expo.modules.kotlin.events.BasicEventListener
 import expo.modules.kotlin.events.EventListener
 import expo.modules.kotlin.events.EventListenerWithPayload
@@ -13,10 +15,11 @@ import expo.modules.kotlin.events.EventListenerWithSenderAndPayload
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.OnActivityResultPayload
 import expo.modules.kotlin.objects.ObjectDefinitionBuilder
+import expo.modules.kotlin.sharedobjects.SharedObject
 import expo.modules.kotlin.views.ViewDefinitionBuilder
 import expo.modules.kotlin.views.ViewManagerDefinition
-import expo.modules.kotlin.views.ViewManagerDefinitionBuilder
 import kotlin.reflect.KClass
+import kotlin.reflect.typeOf
 
 @DefinitionMarker
 class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null) : ObjectDefinitionBuilder() {
@@ -31,6 +34,9 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
   @PublishedApi
   internal var registerContracts: (suspend AppContextActivityResultCaller.() -> Unit)? = null
 
+  @PublishedApi
+  internal var classData = mutableListOf<ClassDefinitionData>()
+
   fun buildModule(): ModuleDefinitionData {
     val moduleName = name ?: module?.javaClass?.simpleName
 
@@ -39,7 +45,8 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
       buildObject(),
       viewManagerDefinition,
       eventListeners,
-      registerContracts
+      registerContracts,
+      classData
     )
   }
 
@@ -53,22 +60,10 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
   /**
    * Creates the view manager definition that scopes other view-related definitions.
    */
-  @Deprecated(message = "Use a `View` component instead.")
-  inline fun ViewManager(body: ViewManagerDefinitionBuilder.() -> Unit) {
+  inline fun <reified T : View> View(viewClass: KClass<T>, body: ViewDefinitionBuilder<T>.() -> Unit) {
     require(viewManagerDefinition == null) { "The module definition may have exported only one view manager." }
 
-    val viewManagerDefinitionBuilder = ViewManagerDefinitionBuilder()
-    body.invoke(viewManagerDefinitionBuilder)
-    viewManagerDefinition = viewManagerDefinitionBuilder.build()
-  }
-
-  /**
-   * Creates the view manager definition that scopes other view-related definitions.
-   */
-  inline fun <T : View> View(viewType: KClass<T>, body: ViewDefinitionBuilder<T>.() -> Unit) {
-    require(viewManagerDefinition == null) { "The module definition may have exported only one view manager." }
-
-    val viewDefinitionBuilder = ViewDefinitionBuilder(viewType)
+    val viewDefinitionBuilder = ViewDefinitionBuilder(viewClass, typeOf<T>())
     body.invoke(viewDefinitionBuilder)
     viewManagerDefinition = viewDefinitionBuilder.build()
   }
@@ -129,4 +124,19 @@ class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null)
     eventListeners[EventName.ON_ACTIVITY_RESULT] =
       EventListenerWithSenderAndPayload<Activity, OnActivityResultPayload>(EventName.ON_ACTIVITY_RESULT) { sender, payload -> body(sender, payload) }
   }
+
+  inline fun Class(name: String, body: ClassComponentBuilder<Unit>.() -> Unit = {}) {
+    val clazzBuilder = ClassComponentBuilder(name, Unit::class, typeOf<Unit>())
+    body.invoke(clazzBuilder)
+    classData.add(clazzBuilder.buildClass())
+  }
+
+  inline fun <reified SharedObjectType : SharedObject> Class(
+    sharedObjectClass: KClass<SharedObjectType>,
+    body: ClassComponentBuilder<SharedObjectType>.() -> Unit = {}
+  ) {
+    val clazzBuilder = ClassComponentBuilder(sharedObjectClass.java.simpleName, sharedObjectClass, typeOf<SharedObjectType>())
+    body.invoke(clazzBuilder)
+    classData.add(clazzBuilder.buildClass())
+  }
 }

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

@@ -1,6 +1,7 @@
 package expo.modules.kotlin.modules
 
 import expo.modules.kotlin.activityresult.AppContextActivityResultCaller
+import expo.modules.kotlin.classcomponent.ClassDefinitionData
 import expo.modules.kotlin.events.EventListener
 import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.objects.ObjectDefinitionData
@@ -11,7 +12,8 @@ class ModuleDefinitionData(
   val objectDefinition: ObjectDefinitionData,
   val viewManagerDefinition: ViewManagerDefinition? = null,
   val eventListeners: Map<EventName, EventListener> = emptyMap(),
-  val registerContracts: (suspend AppContextActivityResultCaller.() -> Unit)? = null
+  val registerContracts: (suspend AppContextActivityResultCaller.() -> Unit)? = null,
+  val classData: List<ClassDefinitionData> = emptyList()
 ) {
 
   val constantsProvider = objectDefinition.constantsProvider

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedObject.kt

@@ -0,0 +1,12 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.core.interfaces.DoNotStrip
+
+@DoNotStrip
+open class SharedObject {
+  /**
+   * An identifier of the native shared object that maps to the JavaScript object.
+   * When the object is not linked with any JavaScript object, its value is 0.
+   */
+  internal var sharedObjectId: SharedObjectId = SharedObjectId(0)
+}

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedObjectRegistry.kt

@@ -0,0 +1,62 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.kotlin.jni.JavaScriptObject
+
+@JvmInline
+value class SharedObjectId(val value: Int)
+
+// TODO(@lukmccall): use weak ref to hold js object
+typealias SharedObjectPair = Pair<SharedObject, JavaScriptObject>
+
+const val sharedObjectIdPropertyName = "__expo_shared_object_id__"
+
+class SharedObjectRegistry {
+  private var currentId: SharedObjectId = SharedObjectId(1)
+
+  internal var pairs = mutableMapOf<SharedObjectId, SharedObjectPair>()
+
+  private fun pullNextId(): SharedObjectId {
+    val current = currentId
+    currentId = SharedObjectId(current.value + 1)
+    return current
+  }
+
+  internal fun add(native: SharedObject, js: JavaScriptObject): SharedObjectId {
+    val id = pullNextId()
+    native.sharedObjectId = id
+    js.defineProperty(sharedObjectIdPropertyName, id.value)
+
+    js.defineDeallocator {
+      delete(id)
+    }
+
+    pairs[id] = native to js
+    return id
+  }
+
+  internal fun delete(id: SharedObjectId) {
+    pairs.remove(id)?.let { (native, js) ->
+      native.sharedObjectId = SharedObjectId(0)
+      if (js.isValid()) {
+        js.defineProperty(sharedObjectIdPropertyName, 0)
+      }
+    }
+  }
+
+  internal fun toNativeObject(id: SharedObjectId): SharedObject? {
+    return pairs[id]?.first
+  }
+
+  internal fun toNativeObject(js: JavaScriptObject): SharedObject? {
+    if (!js.hasProperty(sharedObjectIdPropertyName)) {
+      return null
+    }
+
+    val id = SharedObjectId(js.getProperty(sharedObjectIdPropertyName).getInt())
+    return pairs[id]?.first
+  }
+
+  internal fun toJavaScriptObjet(native: SharedObject): JavaScriptObject? {
+    return pairs[native.sharedObjectId]?.second
+  }
+}

package/android/src/main/java/expo/modules/kotlin/sharedobjects/SharedObjectTypeConverter.kt

@@ -0,0 +1,27 @@
+package expo.modules.kotlin.sharedobjects
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.exception.InvalidSharedObjectException
+import expo.modules.kotlin.jni.CppType
+import expo.modules.kotlin.jni.ExpectedType
+import expo.modules.kotlin.toStrongReference
+import expo.modules.kotlin.types.NullAwareTypeConverter
+import kotlin.reflect.KType
+
+class SharedObjectTypeConverter<T : SharedObject>(
+  val type: KType
+) : NullAwareTypeConverter<T>(type.isMarkedNullable) {
+  @Suppress("UNCHECKED_CAST")
+  override fun convertNonOptional(value: Any, context: AppContext?): T {
+    val id = SharedObjectId(value as Int)
+    val appContext = context.toStrongReference()
+    val result = appContext.sharedObjectRegistry.toNativeObject(id)
+      ?: throw InvalidSharedObjectException(type)
+
+    return result as T
+  }
+
+  override fun getCppRequiredTypes() = ExpectedType(CppType.SHARED_OBJECT_ID)
+
+  override fun isTrivial(): Boolean = false
+}

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

@@ -1,5 +1,6 @@
 package expo.modules.kotlin.types
 
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.jni.ExpectedType
 import kotlin.reflect.KType
 
@@ -10,7 +11,7 @@ class AnyType(val kType: KType) {
     TypeConverterProviderImpl.obtainTypeConverter(kType)
   }
 
-  fun convert(value: Any?): Any? = converter.convert(value)
+  fun convert(value: Any?, appContext: AppContext? = null): Any? = converter.convert(value, appContext)
 
   fun getCppRequiredTypes(): ExpectedType = converter.getCppRequiredTypes()
 }

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

@@ -1,5 +1,6 @@
 package expo.modules.kotlin.types
 
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.apifeatures.EitherType
 import expo.modules.kotlin.jni.ExpectedType
 import expo.modules.kotlin.jni.SingleType
@@ -9,7 +10,7 @@ import kotlin.reflect.KType
 class EitherTypeConverter<FirstType : Any, SecondType : Any>(
   converterProvider: TypeConverterProvider,
   eitherType: KType,
-) : TypeConverter<Either<FirstType, SecondType>>(eitherType.isMarkedNullable) {
+) : NullAwareTypeConverter<Either<FirstType, SecondType>>(eitherType.isMarkedNullable) {
   private val firstJavaType = requireNotNull(eitherType.arguments.getOrNull(0)?.type)
   private val secondJavaType = requireNotNull(eitherType.arguments.getOrNull(1)?.type)
   private val firstTypeConverter = converterProvider.obtainTypeConverter(
@@ -21,7 +22,7 @@ class EitherTypeConverter<FirstType : Any, SecondType : Any>(
   private val firstType = firstTypeConverter.getCppRequiredTypes()
   private val secondType = secondTypeConverter.getCppRequiredTypes()
 
-  override fun convertNonOptional(value: Any): Either<FirstType, SecondType> {
+  override fun convertNonOptional(value: Any, context: AppContext?): Either<FirstType, SecondType> {
     val convertValueIfNeeded = Convert@{ types: Array<out SingleType>, converter: TypeConverter<*> ->
       for (singleType in types) {
         if (singleType.expectedCppType.clazz.isInstance(value)) {
@@ -54,7 +55,7 @@ class EitherTypeConverter<FirstType : Any, SecondType : Any>(
 class EitherOfThreeTypeConverter<FirstType : Any, SecondType : Any, ThirdType : Any>(
   converterProvider: TypeConverterProvider,
   eitherType: KType,
-) : TypeConverter<EitherOfThree<FirstType, SecondType, ThirdType>>(eitherType.isMarkedNullable) {
+) : NullAwareTypeConverter<EitherOfThree<FirstType, SecondType, ThirdType>>(eitherType.isMarkedNullable) {
   private val firstJavaType = requireNotNull(eitherType.arguments.getOrNull(0)?.type)
   private val secondJavaType = requireNotNull(eitherType.arguments.getOrNull(1)?.type)
   private val thirdJavaType = requireNotNull(eitherType.arguments.getOrNull(2)?.type)
@@ -71,7 +72,7 @@ class EitherOfThreeTypeConverter<FirstType : Any, SecondType : Any, ThirdType :
   private val secondType = secondTypeConverter.getCppRequiredTypes()
   private val thirdType = thirdTypeConverter.getCppRequiredTypes()
 
-  override fun convertNonOptional(value: Any): EitherOfThree<FirstType, SecondType, ThirdType> {
+  override fun convertNonOptional(value: Any, context: AppContext?): EitherOfThree<FirstType, SecondType, ThirdType> {
     val convertValueIfNeeded = Convert@{ types: Array<out SingleType>, converter: TypeConverter<*> ->
       for (singleType in types) {
         if (singleType.expectedCppType.clazz.isInstance(value)) {
@@ -105,7 +106,7 @@ class EitherOfThreeTypeConverter<FirstType : Any, SecondType : Any, ThirdType :
 class EitherOfFourTypeConverter<FirstType : Any, SecondType : Any, ThirdType : Any, FourthType : Any>(
   converterProvider: TypeConverterProvider,
   eitherType: KType,
-) : TypeConverter<EitherOfFour<FirstType, SecondType, ThirdType, FourthType>>(eitherType.isMarkedNullable) {
+) : NullAwareTypeConverter<EitherOfFour<FirstType, SecondType, ThirdType, FourthType>>(eitherType.isMarkedNullable) {
   private val firstJavaType = requireNotNull(eitherType.arguments.getOrNull(0)?.type)
   private val secondJavaType = requireNotNull(eitherType.arguments.getOrNull(1)?.type)
   private val thirdJavaType = requireNotNull(eitherType.arguments.getOrNull(2)?.type)
@@ -127,7 +128,7 @@ class EitherOfFourTypeConverter<FirstType : Any, SecondType : Any, ThirdType : A
   private val thirdType = thirdTypeConverter.getCppRequiredTypes()
   private val fourthType = fourthTypeConverter.getCppRequiredTypes()
 
-  override fun convertNonOptional(value: Any): EitherOfFour<FirstType, SecondType, ThirdType, FourthType> {
+  override fun convertNonOptional(value: Any, context: AppContext?): EitherOfFour<FirstType, SecondType, ThirdType, FourthType> {
     val convertValueIfNeeded = Convert@{ types: Array<out SingleType>, converter: TypeConverter<*> ->
       for (singleType in types) {
         if (singleType.expectedCppType.clazz.isInstance(value)) {

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

@@ -0,0 +1,22 @@
+package expo.modules.kotlin.types
+
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.jni.CppType
+import expo.modules.kotlin.jni.ExpectedType
+import expo.modules.kotlin.jni.JavaScriptFunction
+import kotlin.reflect.KType
+
+class JavaScriptFunctionTypeConverter<T : Any>(
+  val type: KType
+) : NullAwareTypeConverter<JavaScriptFunction<T>>(type.isMarkedNullable) {
+  override fun convertNonOptional(value: Any, context: AppContext?): JavaScriptFunction<T> {
+    @Suppress("UNCHECKED_CAST")
+    val jsFunction = value as JavaScriptFunction<T>
+    jsFunction.returnType = requireNotNull(type.arguments.first().type)
+    return jsFunction
+  }
+
+  override fun getCppRequiredTypes(): ExpectedType = ExpectedType(CppType.JS_FUNCTION)
+
+  override fun isTrivial(): Boolean = false
+}

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.AppContext
 import expo.modules.kotlin.exception.NullArgumentException
 import expo.modules.kotlin.exception.UnsupportedClass
 import expo.modules.kotlin.jni.ExpectedType
@@ -9,30 +10,11 @@ import expo.modules.kotlin.jni.ExpectedType
  * Basic type converter. It has to handle two different inputs - [Dynamic] and [Any].
  * The first one is used in the bridge implementation. The second one is used in the JSI.
  */
-abstract class TypeConverter<Type : Any>(
-  /**
-   * Whether `null` can be assigned to the desired type.
-   */
-  private val isOptional: Boolean
-) {
+abstract class TypeConverter<Type : Any> {
   /**
    * Tries to convert from [Any]? (can be also [Dynamic]) to the desired type.
    */
-  open fun convert(value: Any?): Type? {
-    if (value == null || value is Dynamic && value.isNull) {
-      if (isOptional) {
-        return null
-      }
-      throw NullArgumentException()
-    }
-    return convertNonOptional(value)
-  }
-
-  /**
-   * Tries to convert from [Any] to the desired type.
-   * We know in that place that we're not dealing with `null`.
-   */
-  abstract fun convertNonOptional(value: Any): Type
+  abstract fun convert(value: Any?, context: AppContext? = null): Type?
 
   /**
    * Returns a list of [ExpectedType] types that can be converted to the desired type.
@@ -40,7 +22,7 @@ abstract class TypeConverter<Type : Any>(
    * For instance js object can be pass as [Map] or [expo.modules.kotlin.jni.JavaScriptObject].
    * This value tells us which one we should choose.
    */
-  abstract fun getCppRequiredTypes(): ExpectedType
+  open fun getCppRequiredTypes(): ExpectedType = ExpectedType.forAny()
 
   /**
    * Checks if the current converter is a trivial one.
@@ -50,13 +32,36 @@ abstract class TypeConverter<Type : Any>(
   open fun isTrivial(): Boolean = true
 }
 
+abstract class NullAwareTypeConverter<Type : Any>(
+  /**
+   * Whether `null` can be assigned to the desired type.
+   */
+  private val isOptional: Boolean
+) : TypeConverter<Type>() {
+  override fun convert(value: Any?, context: AppContext?): Type? {
+    if (value == null || value is Dynamic && value.isNull) {
+      if (isOptional) {
+        return null
+      }
+      throw NullArgumentException()
+    }
+    return convertNonOptional(value, context)
+  }
+
+  /**
+   * Tries to convert from [Any] to the desired type.
+   * We know in that place that we're not dealing with `null`.
+   */
+  abstract fun convertNonOptional(value: Any, context: AppContext?): Type
+}
+
 /**
  * A helper class to make a clear separation between [Any] and [Dynamic].
  * Right it is used as a default base class for all converters, but this will change when we
  * stop using the bridge to pass data between JS and Kotlin.
  */
-abstract class DynamicAwareTypeConverters<T : Any>(isOptional: Boolean) : TypeConverter<T>(isOptional) {
-  override fun convertNonOptional(value: Any): T =
+abstract class DynamicAwareTypeConverters<T : Any>(isOptional: Boolean) : NullAwareTypeConverter<T>(isOptional) {
+  override fun convertNonOptional(value: Any, context: AppContext?): T =
     if (value is Dynamic) {
       convertFromDynamic(value)
     } else {
@@ -75,6 +80,7 @@ inline fun <reified T : Any> createTrivialTypeConverter(
   return object : DynamicAwareTypeConverters<T>(isOptional) {
     override fun convertFromDynamic(value: Dynamic): T = dynamicFallback(value)
     override fun getCppRequiredTypes(): ExpectedType = cppRequireType
+
     @Suppress("UNCHECKED_CAST")
     override fun convertFromAny(value: Any): T = value as T
   }