expo-modules-core 1.2.6 → 1.3.0

package/android/src/main/java/expo/modules/kotlin/classcomponent/ClassComponentBuilder.kt

@@ -0,0 +1,112 @@
+@file:Suppress("FunctionName")
+
+package expo.modules.kotlin.classcomponent
+
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.objects.ObjectDefinitionBuilder
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.KClass
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+class ClassComponentBuilder<SharedObjectType : Any>(
+  val name: String,
+  private val ownerClass: KClass<SharedObjectType>,
+  private val ownerType: KType
+) : ObjectDefinitionBuilder() {
+  var constructor: SyncFunctionComponent? = null
+
+  fun buildClass(): ClassDefinitionData {
+    val objectData = buildObject()
+    objectData.functions.forEach {
+      it.ownerType = ownerType
+      it.canTakeOwner = true
+    }
+
+    val hasSharedObject = ownerClass !== Unit::class
+    if (hasSharedObject && constructor == null) {
+      throw IllegalArgumentException("constructor cannot be null")
+    }
+
+    val constructor = constructor ?: SyncFunctionComponent("constructor", arrayOf()) {}
+    constructor.canTakeOwner = true
+
+    return ClassDefinitionData(
+      name,
+      constructor,
+      objectData,
+    )
+  }
+
+  inline fun Constructor(
+    crossinline body: () -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", arrayOf()) { body() }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0> Constructor(
+    crossinline body: (p0: P0) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType())) { body(it[0] as P0) }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1> Constructor(
+    crossinline body: (p0: P0, p1: P1) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType())) { body(it[0] as P0, it[1] as P1) }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1, reified P2> Constructor(
+    crossinline body: (p0: P0, p1: P1, p2: P2) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", arrayOf(typeOf<P0>().toAnyType(), typeOf<P1>().toAnyType(), typeOf<P2>().toAnyType())) { body(it[0] as P0, it[1] as P1, it[2] as P2) }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1, reified P2, reified P3> Constructor(
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", 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) }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1, reified P2, reified P3, reified P4> Constructor(
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", 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) }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> Constructor(
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", 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 {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> Constructor(
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", 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) }.also {
+      constructor = it
+    }
+  }
+
+  inline fun <reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> Constructor(
+    crossinline body: (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> SharedObjectType
+  ): SyncFunctionComponent {
+    return SyncFunctionComponent("constructor", 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) }.also {
+      constructor = it
+    }
+  }
+}

package/android/src/main/java/expo/modules/kotlin/classcomponent/ClassDefinitionData.kt

@@ -0,0 +1,10 @@
+package expo.modules.kotlin.classcomponent
+
+import expo.modules.kotlin.functions.SyncFunctionComponent
+import expo.modules.kotlin.objects.ObjectDefinitionData
+
+class ClassDefinitionData(
+  val name: String,
+  val constructor: SyncFunctionComponent,
+  val objectDefinition: ObjectDefinitionData
+)

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

@@ -7,6 +7,12 @@ import kotlin.reflect.KClass
 import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
 
+@Suppress("NOTHING_TO_INLINE")
+inline fun Throwable.toCodedException() = when (this) {
+  is CodedException -> this
+  else -> UnexpectedException(this)
+}
+
 /**
  * A class for errors specifying its `code` and providing the `description`.
  */
@@ -85,6 +91,7 @@ internal class MissingTypeConverter(
   message = "Cannot find type converter for '$forType'.",
 )
 
+@DoNotStrip
 internal class InvalidArgsNumberException(received: Int, expected: Int, required: Int = expected) :
   CodedException(
     message = if (required < expected) {
@@ -145,6 +152,14 @@ internal class PropSetException(
   cause,
 )
 
+internal class OnViewDidUpdatePropsException(
+  viewType: KClass<*>,
+  cause: CodedException
+) : DecoratedException(
+  message = "Error occurred when invoking 'onViewDidUpdateProps' on '${viewType.simpleName}'",
+  cause
+)
+
 internal class ArgumentCastException(
   argDesiredType: KType,
   argIndex: Int,
@@ -165,6 +180,12 @@ internal class ArgumentCastException(
   }
 }
 
+internal class InvalidSharedObjectException(
+  sharedType: KType,
+) : CodedException(
+  message = "Cannot convert provided JavaScriptObject to the '$sharedType', because it doesn't contain valid id"
+)
+
 internal class FieldCastException(
   fieldName: String,
   fieldType: KType,

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

@@ -14,6 +14,11 @@ class Exceptions {
     viewTag: Int
   ) : CodedException(message = "Unable to find the $viewType view with tag $viewTag")
 
+  /**
+   * The app context is no longer available.
+   */
+  class AppContextLost : CodedException(message = "The app context has been lost")
+
   /**
    * The react app context is no longer available.
    */
@@ -43,4 +48,14 @@ class Exceptions {
    * An exception to throw when the current Android activity is not longer available.
    */
   class MissingActivity : CodedException(message = "The current activity is no longer available")
+
+  /**
+   * An exception to throw when function was called on the incorrect thread.
+   */
+  class IncorrectThreadException(
+    currentThreadName: String,
+    expectedThreadName: String
+  ) : CodedException(
+    message = "Expected to run on $expectedThreadName thread, but was run on $currentThreadName"
+  )
 }

package/android/src/main/java/expo/modules/kotlin/functions/AnyFunction.kt

@@ -1,7 +1,6 @@
 package expo.modules.kotlin.functions
 
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableType
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.exception.ArgumentCastException
 import expo.modules.kotlin.exception.CodedException
@@ -10,8 +9,12 @@ import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.iterator
 import expo.modules.kotlin.jni.ExpectedType
 import expo.modules.kotlin.jni.JavaScriptModuleObject
+import expo.modules.kotlin.jni.JavaScriptObject
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.AnyType
+import kotlin.reflect.KType
+import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.typeOf
 
 /**
  * Base class of all exported functions
@@ -22,6 +25,16 @@ abstract class AnyFunction(
 ) {
   internal val argsCount get() = desiredArgsTypes.size
 
+  internal var canTakeOwner: Boolean = false
+
+  @PublishedApi
+  internal var ownerType: KType? = null
+
+  internal val takesOwner: Boolean
+    get() = canTakeOwner &&
+      desiredArgsTypes.firstOrNull()?.kType?.isSubtypeOf(typeOf<JavaScriptObject>()) == true ||
+      (ownerType != null && desiredArgsTypes.firstOrNull()?.kType?.isSubtypeOf(ownerType!!) == true)
+
   /**
    * A minimum number of arguments the functions needs which equals to `argumentsCount` reduced by the number of trailing optional arguments.
    */
@@ -30,7 +43,7 @@ abstract class AnyFunction(
       .reversed()
       .indexOfFirst { !it.kType.isMarkedNullable }
     if (nonNullableArgIndex < 0) {
-      return@run desiredArgsTypes.size
+      return@run 0
     }
 
     return@run desiredArgsTypes.size - nonNullableArgIndex
@@ -70,7 +83,7 @@ abstract class AnyFunction(
    * @throws `CodedException` if conversion isn't possible
    */
   @Throws(CodedException::class)
-  protected fun convertArgs(args: Array<Any?>): Array<out Any?> {
+  protected fun convertArgs(args: Array<Any?>, appContext: AppContext? = null): Array<out Any?> {
     if (requiredArgumentsCount > args.size || args.size > desiredArgsTypes.size) {
       throw InvalidArgsNumberException(args.size, desiredArgsTypes.size, requiredArgumentsCount)
     }
@@ -83,7 +96,7 @@ abstract class AnyFunction(
       exceptionDecorator({ cause ->
         ArgumentCastException(desiredType.kType, index, element?.javaClass.toString(), cause)
       }) {
-        finalArgs[index] = desiredType.convert(element)
+        finalArgs[index] = desiredType.convert(element, appContext)
       }
     }
     return finalArgs

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunction.kt

@@ -1,10 +1,16 @@
 package expo.modules.kotlin.functions
 
+import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.common.UIManagerType
+import expo.modules.BuildConfig
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.ModuleHolder
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.exception.FunctionCallException
 import expo.modules.kotlin.exception.UnexpectedException
 import expo.modules.kotlin.exception.exceptionDecorator
@@ -48,25 +54,21 @@ abstract class AsyncFunction(
   @Throws(CodedException::class)
   internal abstract fun callUserImplementation(args: ReadableArray, promise: Promise)
 
-  internal abstract fun callUserImplementation(args: Array<Any?>, promise: Promise)
+  internal abstract fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext)
 
   override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
     jsObject.registerAsyncFunction(
       name,
+      takesOwner,
       argsCount,
       desiredArgsTypes.map { it.getCppRequiredTypes() }.toTypedArray()
     ) { args, bridgePromise ->
-      val queue = when (queue) {
-        Queues.MAIN -> appContext.mainQueue
-        Queues.DEFAULT -> appContext.modulesQueue
-      }
-
-      queue.launch {
+      val functionBody = {
         try {
           exceptionDecorator({
             FunctionCallException(name, jsObject.name, it)
           }) {
-            callUserImplementation(args, bridgePromise)
+            callUserImplementation(args, bridgePromise, appContext)
           }
         } catch (e: CodedException) {
           bridgePromise.reject(e)
@@ -74,6 +76,34 @@ abstract class AsyncFunction(
           bridgePromise.reject(UnexpectedException(e))
         }
       }
+
+      if (queue == Queues.MAIN) {
+        if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+          // On certain occasions, invoking a function on a view could lead to an error
+          // because of the asynchronous communication between the JavaScript and native components.
+          // In such cases, the native view may not have been mounted yet,
+          // but the JavaScript code has already received the future tag of the view.
+          // To avoid this issue, we have decided to temporarily utilize
+          // the UIManagerModule for dispatching functions on the main thread.
+          val uiManager = UIManagerHelper.getUIManagerForReactTag(
+            appContext.reactContext as? ReactContext ?: throw Exceptions.ReactContextLost(),
+            UIManagerType.DEFAULT
+          ) as UIManagerModule
+
+          uiManager.addUIBlock {
+            functionBody()
+          }
+          return@registerAsyncFunction
+        }
+
+        appContext.mainQueue.launch {
+          functionBody()
+        }
+      } else {
+        appContext.modulesQueue.launch {
+          functionBody()
+        }
+      }
     }
   }
 }

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionComponent.kt

@@ -1,6 +1,7 @@
 package expo.modules.kotlin.functions
 
 import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.types.AnyType
@@ -15,7 +16,7 @@ class AsyncFunctionComponent(
     promise.resolve(body(convertArgs(args)))
   }
 
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise) {
-    promise.resolve(body(convertArgs(args)))
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    promise.resolve(body(convertArgs(args, appContext)))
   }
 }

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunctionWithPromiseComponent.kt

@@ -1,6 +1,7 @@
 package expo.modules.kotlin.functions
 
 import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.types.AnyType
@@ -15,7 +16,7 @@ class AsyncFunctionWithPromiseComponent(
     body(convertArgs(args), promise)
   }
 
-  override fun callUserImplementation(args: Array<Any?>, promise: Promise) {
-    body(convertArgs(args), promise)
+  override fun callUserImplementation(args: Array<Any?>, promise: Promise, appContext: AppContext) {
+    body(convertArgs(args, appContext), promise)
   }
 }

package/android/src/main/java/expo/modules/kotlin/functions/SuspendFunctionComponent.kt

@@ -48,6 +48,7 @@ class SuspendFunctionComponent(
   override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
     jsObject.registerAsyncFunction(
       name,
+      takesOwner,
       argsCount,
       desiredArgsTypes.map { it.getCppRequiredTypes() }.toTypedArray()
     ) { args, bridgePromise ->

package/android/src/main/java/expo/modules/kotlin/functions/SyncFunctionComponent.kt

@@ -5,6 +5,7 @@ import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.exception.CodedException
 import expo.modules.kotlin.exception.FunctionCallException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.JNIFunctionBody
 import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.types.AnyType
 import expo.modules.kotlin.types.JSTypeConverter
@@ -19,22 +20,28 @@ class SyncFunctionComponent(
     return body(convertArgs(args))
   }
 
-  fun call(args: Array<Any?>): Any? {
-    return body(convertArgs(args))
+  fun call(args: Array<Any?>, appContext: AppContext? = null): Any? {
+    return body(convertArgs(args, appContext))
   }
 
-  override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
-    jsObject.registerSyncFunction(
-      name,
-      argsCount,
-      getCppRequiredTypes().toTypedArray()
-    ) { args ->
-      return@registerSyncFunction exceptionDecorator({
-        FunctionCallException(name, jsObject.name, it)
+  internal fun getJNIFunctionBody(moduleName: String, appContext: AppContext?): JNIFunctionBody {
+    return JNIFunctionBody { args ->
+      return@JNIFunctionBody exceptionDecorator({
+        FunctionCallException(name, moduleName, it)
       }) {
-        val result = call(args)
+        val result = call(args, appContext)
         return@exceptionDecorator JSTypeConverter.convertToJSValue(result)
       }
     }
   }
+
+  override fun attachToJSObject(appContext: AppContext, jsObject: JavaScriptModuleObject) {
+    jsObject.registerSyncFunction(
+      name,
+      takesOwner,
+      argsCount,
+      getCppRequiredTypes().toTypedArray(),
+      getJNIFunctionBody(jsObject.name, appContext)
+    )
+  }
 }

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

@@ -27,5 +27,8 @@ enum class CppType(val clazz: KClass<*>, val value: Int = nextValue()) {
   TYPED_ARRAY(TypedArray::class),
   PRIMITIVE_ARRAY(Array::class),
   LIST(List::class),
-  MAP(Map::class);
+  MAP(Map::class),
+  VIEW_TAG(Int::class),
+  SHARED_OBJECT_ID(Int::class),
+  JS_FUNCTION(JavaScriptFunction::class);
 }

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

@@ -0,0 +1,73 @@
+package expo.modules.kotlin.jni
+
+import java.lang.ref.PhantomReference
+import java.lang.ref.ReferenceQueue
+import java.lang.ref.WeakReference
+
+interface Destructible {
+  fun deallocate()
+}
+
+object JNIDeallocator {
+  /**
+   * A [PhantomReference] queue managed by JVM
+   */
+  private val referenceQueue = ReferenceQueue<Destructible>()
+
+  /**
+   * A registry to keep all active [Destructible] objects and their [PhantomReference]s
+   */
+  private val destructorMap = mutableMapOf<PhantomReference<Destructible>, WeakReference<Destructible>>()
+
+  /**
+   * A thread that clears your registry when an object has been garbage collected
+   * to not store invalid references to every created object.
+   */
+  private val destructorThread = object : Thread("Expo JNI deallocator") {
+    override fun run() {
+      while (true) {
+        try {
+          // Referent of PhantomReference were garbage collected so we can remove it from our registry.
+          // Note that we don't have to call `deallocate` method - it was called [com.facebook.jni.HybridData].
+          val current = referenceQueue.remove()
+          synchronized(this) {
+            destructorMap.remove(current)
+          }
+        } catch (e: InterruptedException) {
+          // Continue. This thread should never be terminated.
+        }
+      }
+    }
+  }.also {
+    it.start()
+  }
+
+  /**
+   * Adds reference to the internal registry.
+   * That reference will be deallocated when [JNIDeallocator.deallocate] is called or
+   * when the reference won't be reachable by the GC.
+   */
+  internal fun addReference(destructible: Destructible) = synchronized(this) {
+    val weakRef = WeakReference(destructible)
+    val phantomRef = PhantomReference(destructible, referenceQueue)
+    destructorMap[phantomRef] = weakRef
+  }
+
+  /**
+   * Deallocates valid references and clears the internal registry.
+   */
+  internal fun deallocate() = synchronized(this) {
+    destructorMap.values.forEach {
+      it.get()?.deallocate()
+    }
+    destructorMap.clear()
+  }
+
+  /**
+   * Returns references to all hybrid objects that contain references to the jsi value
+   * and are present in the memory.
+   */
+  fun inspectMemory() = synchronized(this) {
+    destructorMap.values.mapNotNull { it.get() }
+  }
+}

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

@@ -6,12 +6,19 @@ import com.facebook.soloader.SoLoader
 import expo.modules.core.interfaces.DoNotStrip
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.exception.JavaScriptEvaluateException
+import expo.modules.kotlin.sharedobjects.SharedObject
 import java.lang.ref.WeakReference
 
+/**
+ * Despite the fact that this class is marked as [Destructible], it is not included in the [JNIDeallocator].
+ * The deallocation of the [JSIInteropModuleRegistry] should be performed at the very end
+ * to prevent the destructor of the [Destructible] object from accessing data that has already been freed.
+ */
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
-class JSIInteropModuleRegistry(appContext: AppContext) {
-  private val appContextHolder = WeakReference(appContext)
+class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
+
+  internal val appContextHolder = WeakReference(appContext)
 
   // Has to be called "mHybridData" - fbjni uses it via reflection
   @DoNotStrip
@@ -68,6 +75,12 @@ class JSIInteropModuleRegistry(appContext: AppContext) {
     return appContextHolder.get()?.registry?.getModuleHolder(name)?.jsObject
   }
 
+  @Suppress("unused")
+  @DoNotStrip
+  fun hasModule(name: String): Boolean {
+    return appContextHolder.get()?.registry?.hasModule(name) ?: false
+  }
+
   /**
    * Returns an array that contains names of available modules.
    */
@@ -77,8 +90,21 @@ class JSIInteropModuleRegistry(appContext: AppContext) {
     return appContextHolder.get()?.registry?.registry?.keys?.toTypedArray() ?: emptyArray()
   }
 
+  @Suppress("unused")
+  @DoNotStrip
+  fun registerSharedObject(native: Any, js: JavaScriptObject) {
+    appContextHolder
+      .get()
+      ?.sharedObjectRegistry
+      ?.add(native as SharedObject, js)
+  }
+
   @Throws(Throwable::class)
   protected fun finalize() {
+    deallocate()
+  }
+
+  override fun deallocate() {
     mHybridData.resetNative()
   }
 

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

@@ -8,7 +8,10 @@ import expo.modules.kotlin.exception.UnexpectedException
 
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
-class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) {
+class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
+  init {
+    JNIDeallocator.addReference(this)
+  }
 
   operator fun invoke(result: Any?) {
     if (result == null) {
@@ -38,6 +41,10 @@ class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHyb
 
   @Throws(Throwable::class)
   protected fun finalize() {
+    deallocate()
+  }
+
+  override fun deallocate() {
     mHybridData.resetNative()
   }
 }

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

@@ -0,0 +1,48 @@
+package expo.modules.kotlin.jni
+
+import com.facebook.jni.HybridData
+import expo.modules.core.interfaces.DoNotStrip
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.types.JSTypeConverter
+import expo.modules.kotlin.types.TypeConverterProviderImpl
+import kotlin.reflect.KType
+import kotlin.reflect.typeOf
+
+@Suppress("KotlinJniMissingFunction")
+@DoNotStrip
+class JavaScriptFunction<ReturnType : Any?> @DoNotStrip private constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
+  init {
+    JNIDeallocator.addReference(this)
+  }
+
+  @PublishedApi
+  internal var returnType: KType? = null
+
+  fun isValid() = mHybridData.isValid
+
+  private external fun invoke(args: Array<Any?>, expectedReturnType: ExpectedType): Any?
+
+  operator fun invoke(vararg args: Any?, appContext: AppContext? = null): ReturnType {
+    // TODO(@lukmccall): check current thread
+    val convertedArgs = args
+      .map { JSTypeConverter.convertToJSValue(it) }
+      .toTypedArray()
+
+    val converter = TypeConverterProviderImpl
+      .obtainTypeConverter(returnType ?: typeOf<Unit>())
+
+    val expectedReturnType = converter.getCppRequiredTypes()
+    val result = invoke(convertedArgs, expectedReturnType)
+    @Suppress("UNCHECKED_CAST")
+    return converter.convert(result, appContext) as ReturnType
+  }
+
+  @Throws(Throwable::class)
+  protected fun finalize() {
+    deallocate()
+  }
+
+  override fun deallocate() {
+    mHybridData.resetNative()
+  }
+}