expo-modules-core 1.11.13 → 1.12.1

package/android/src/main/java/expo/modules/kotlin/jni/{JSIInteropModuleRegistry.kt → JSIContext.kt}

@@ -1,24 +1,27 @@
 package expo.modules.kotlin.jni
 
 import com.facebook.jni.HybridData
+import com.facebook.react.bridge.RuntimeExecutor
+import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
 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 expo.modules.kotlin.sharedobjects.SharedObjectId
+import expo.modules.kotlin.weak
 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
+ * The deallocation of the [JSIContext] 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) : Destructible {
-
-  internal val appContextHolder = WeakReference(appContext)
+class JSIContext : Destructible {
+  internal lateinit var appContextHolder: WeakReference<AppContext> // = WeakReference(appContext)
 
   // Has to be called "mHybridData" - fbjni uses it via reflection
   @DoNotStrip
@@ -26,26 +29,75 @@ class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
 
   private external fun initHybrid(): HybridData
 
+  @OptIn(FrameworkAPI::class)
+  fun installJSI(
+    appContext: AppContext,
+    jsRuntimePointer: Long,
+    jniDeallocator: JNIDeallocator,
+    jsInvokerHolder: CallInvokerHolderImpl
+  ) {
+    appContextHolder = appContext.weak()
+    installJSI(
+      jsRuntimePointer,
+      jniDeallocator,
+      jsInvokerHolder
+    )
+  }
+
+  fun installJSIForBridgeless(
+    appContext: AppContext,
+    jsRuntimePointer: Long,
+    jniDeallocator: JNIDeallocator,
+    runtimeExecutor: RuntimeExecutor
+  ) {
+    appContextHolder = appContext.weak()
+    installJSIForBridgeless(
+      jsRuntimePointer,
+      jniDeallocator,
+      runtimeExecutor
+    )
+  }
+
   /**
    * Initializes the `ExpoModulesHostObject` and adds it to the global object.
    */
-  external fun installJSI(
+  @OptIn(FrameworkAPI::class)
+  private external fun installJSI(
     jsRuntimePointer: Long,
     jniDeallocator: JNIDeallocator,
     jsInvokerHolder: CallInvokerHolderImpl
   )
 
+  private external fun installJSIForBridgeless(
+    jsRuntimePointer: Long,
+    jniDeallocator: JNIDeallocator,
+    runtimeExecutor: RuntimeExecutor
+  )
+
+  @OptIn(FrameworkAPI::class)
+  fun installJSIForTests(
+    appContext: AppContext,
+    jniDeallocator: JNIDeallocator
+  ) {
+    appContextHolder = appContext.weak()
+    installJSIForTests(jniDeallocator)
+  }
+
+  @OptIn(FrameworkAPI::class)
+  fun installJSIForTests(
+    appContext: AppContext
+  ) {
+    appContextHolder = appContext.weak()
+    installJSIForTests(appContext.jniDeallocator)
+  }
+
   /**
    * Initializes the test runtime. Shouldn't be used in the production.
    */
-  external fun installJSIForTests(
+  private external fun installJSIForTests(
     jniDeallocator: JNIDeallocator
   )
 
-  fun installJSIForTests() = installJSIForTests(
-    appContextHolder.get()!!.jniDeallocator
-  )
-
   /**
    * Evaluates given JavaScript source code.
    * @throws JavaScriptEvaluateException if the input format is unknown or evaluation causes an error
@@ -68,10 +120,7 @@ class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
    */
   external fun drainJSEventLoop()
 
-  /**
-   * Informs C++ that runtime was deallocated.
-   */
-  external fun wasDeallocated()
+  external fun setNativeStateForSharedObject(id: Int, js: JavaScriptObject)
 
   /**
    * Returns a `JavaScriptModuleObject` that is a bridge between [expo.modules.kotlin.modules.Module]
@@ -110,6 +159,33 @@ class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
       ?.add(native as SharedObject, js)
   }
 
+  @Suppress("unused")
+  @DoNotStrip
+  fun deleteSharedObject(id: Int) {
+    appContextHolder
+      .get()
+      ?.sharedObjectRegistry
+      ?.delete(SharedObjectId(id))
+  }
+
+  @Suppress("unused")
+  @DoNotStrip
+  fun registerClass(native: Class<*>, js: JavaScriptObject) {
+    appContextHolder
+      .get()
+      ?.classRegistry
+      ?.add(native, js)
+  }
+
+  @Suppress("unused")
+  @DoNotStrip
+  fun getJavascriptClass(native: java.lang.Class<*>): JavaScriptObject? {
+    return appContextHolder
+      .get()
+      ?.classRegistry
+      ?.toJavaScriptObject(native)
+  }
+
   @Suppress("unused")
   @DoNotStrip
   fun getCoreModuleObject(): JavaScriptModuleObject? {

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

@@ -6,26 +6,62 @@ import com.facebook.react.bridge.WritableNativeMap
 import expo.modules.core.interfaces.DoNotStrip
 import expo.modules.kotlin.exception.UnexpectedException
 import expo.modules.kotlin.logger
+import expo.modules.kotlin.sharedobjects.SharedRef
 
 @Suppress("KotlinJniMissingFunction")
 @DoNotStrip
 class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHybridData: HybridData) : Destructible {
-  operator fun invoke(result: Any?) {
+  operator fun invoke(result: Any?) = checkIfValid {
+    if (result == null) {
+      invokeNative()
+      return
+    }
+    when (result) {
+      is Int -> invokeNative(result)
+      is Boolean -> invokeNative(result)
+      is Double -> invokeNative(result)
+      is Float -> invokeNative(result)
+      is String -> invokeNative(result)
+      is WritableNativeArray -> invokeNative(result)
+      is WritableNativeMap -> invokeNative(result)
+      is SharedRef<*> -> invokeNative(result)
+      else -> throw UnexpectedException("Unknown type: ${result.javaClass}")
+    }
+  }
+
+  operator fun invoke(result: Int) = checkIfValid {
+    invokeNative(result)
+  }
+
+  operator fun invoke(result: Boolean) = checkIfValid {
+    invokeNative(result)
+  }
+
+  operator fun invoke(result: Double) = checkIfValid {
+    invokeNative(result)
+  }
+
+  operator fun invoke(result: Float) = checkIfValid {
+    invokeNative(result)
+  }
+
+  operator fun invoke(result: String) = checkIfValid {
+    invokeNative(result)
+  }
+
+  private external fun invokeNative()
+  private external fun invokeNative(result: Int)
+  private external fun invokeNative(result: Boolean)
+  private external fun invokeNative(result: Double)
+  private external fun invokeNative(result: Float)
+  private external fun invokeNative(result: String)
+  private external fun invokeNative(result: WritableNativeArray)
+  private external fun invokeNative(result: WritableNativeMap)
+  private external fun invokeNative(result: SharedRef<*>)
+
+  private inline fun checkIfValid(body: () -> Unit) {
     try {
-      if (result == null) {
-        invoke()
-        return
-      }
-      when (result) {
-        is Int -> invoke(result)
-        is Boolean -> invoke(result)
-        is Double -> invoke(result)
-        is Float -> invoke(result)
-        is String -> invoke(result)
-        is WritableNativeArray -> invoke(result)
-        is WritableNativeMap -> invoke(result)
-        else -> throw UnexpectedException("Unknown type: ${result.javaClass}")
-      }
+      body()
     } catch (e: Throwable) {
       if (!mHybridData.isValid) {
         // We know that this particular JavaCallback was invalidated, so it shouldn't be invoked.
@@ -37,15 +73,6 @@ class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHyb
     }
   }
 
-  private external fun invoke()
-  private external fun invoke(result: Int)
-  private external fun invoke(result: Boolean)
-  private external fun invoke(result: Double)
-  private external fun invoke(result: Float)
-  private external fun invoke(result: String)
-  private external fun invoke(result: WritableNativeArray)
-  private external fun invoke(result: WritableNativeMap)
-
   @Throws(Throwable::class)
   protected fun finalize() {
     deallocate()

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

@@ -17,9 +17,9 @@ class JavaScriptFunction<ReturnType : Any?> @DoNotStrip private constructor(@DoN
 
   fun isValid() = mHybridData.isValid
 
-  private external fun invoke(args: Array<Any?>, expectedReturnType: ExpectedType): Any?
+  private external fun invoke(thisValue: JavaScriptObject?, args: Array<Any?>, expectedReturnType: ExpectedType): Any?
 
-  operator fun invoke(vararg args: Any?, appContext: AppContext? = null): ReturnType {
+  operator fun invoke(vararg args: Any?, thisValue: JavaScriptObject? = null, appContext: AppContext? = null): ReturnType {
     // TODO(@lukmccall): check current thread
     val convertedArgs = args
       .map { JSTypeConverter.convertToJSValue(it) }
@@ -35,7 +35,7 @@ class JavaScriptFunction<ReturnType : Any?> @DoNotStrip private constructor(@DoN
       )
 
     val expectedReturnType = converter.getCppRequiredTypes()
-    val result = invoke(convertedArgs, expectedReturnType)
+    val result = invoke(thisValue, convertedArgs, expectedReturnType)
     @Suppress("UNCHECKED_CAST")
     return converter.convert(result, appContext) as ReturnType
   }

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

@@ -3,6 +3,7 @@ package expo.modules.kotlin.jni
 import com.facebook.jni.HybridData
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.NativeMap
+import com.facebook.react.bridge.ReadableNativeMap
 import expo.modules.core.interfaces.DoNotStrip
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.objects.ObjectDefinitionData
@@ -82,10 +83,12 @@ class JavaScriptModuleObject(
     setter: JNIFunctionBody?
   )
 
-  external fun registerClass(name: String, classModule: JavaScriptModuleObject, takesOwner: Boolean, desiredTypes: Array<ExpectedType>, body: JNIFunctionBody)
+  external fun registerClass(name: String, classModule: JavaScriptModuleObject, takesOwner: Boolean, ownerClass: Class<*>?, desiredTypes: Array<ExpectedType>, body: JNIFunctionBody)
 
   external fun registerViewPrototype(viewPrototype: JavaScriptModuleObject)
 
+  external fun emitEvent(jsiContext: JSIContext, eventName: String, eventBody: ReadableNativeMap?)
+
   @Throws(Throwable::class)
   protected fun finalize() {
     deallocate()

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

@@ -43,6 +43,7 @@ open class JavaScriptObject @DoNotStrip internal constructor(@DoNotStrip private
   }
 
   external fun getPropertyNames(): Array<String>
+
   external fun createWeak(): JavaScriptWeakObject
 
   private external fun setBoolProperty(name: String, value: Boolean)

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

@@ -36,6 +36,7 @@ class JavaScriptValue @DoNotStrip private constructor(@DoNotStrip private val mH
 
   @PublishedApi
   internal fun <T : Any?> internalJniGetFunction(): JavaScriptFunction<T> = jniGetFunction()
+
   inline fun <reified ReturnType : Any?> getFunction(): JavaScriptFunction<ReturnType> {
     return internalJniGetFunction<ReturnType>().apply {
       returnType = typeOf<ReturnType>()

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

@@ -44,6 +44,26 @@ class PromiseImpl @DoNotStrip internal constructor(
     )
   }
 
+  override fun resolve(result: Int) = checkIfWasSettled {
+    resolveBlock.invoke(result)
+  }
+
+  override fun resolve(result: Boolean) = checkIfWasSettled {
+    resolveBlock.invoke(result)
+  }
+
+  override fun resolve(result: Double) = checkIfWasSettled {
+    resolveBlock.invoke(result)
+  }
+
+  override fun resolve(result: Float) = checkIfWasSettled {
+    resolveBlock.invoke(result)
+  }
+
+  override fun resolve(result: String) = checkIfWasSettled {
+    resolveBlock.invoke(result)
+  }
+
   // Copy of the reject method from [com.facebook.react.bridge.PromiseImpl]
   override fun reject(code: String, message: String?, cause: Throwable?) = checkIfWasSettled {
     val errorInfo = WritableNativeMap()

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

@@ -24,7 +24,6 @@ abstract class Module : AppContextProvider {
 
   private val moduleEventEmitter by lazy { appContext.eventEmitter(this) }
 
-  @Suppress("PropertyName")
   @PublishedApi
   internal lateinit var coroutineScopeDelegate: Lazy<CoroutineScope>
 

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

@@ -24,7 +24,7 @@ import kotlin.reflect.typeOf
 
 @DefinitionMarker
 class ModuleDefinitionBuilder(@PublishedApi internal val module: Module? = null) : ObjectDefinitionBuilder() {
-  private var name: String? = null
+  internal var name: String? = null
 
   @PublishedApi
   internal var viewManagerDefinition: ViewManagerDefinition? = null