expo-modules-core 0.7.0 → 0.8.0

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

@@ -0,0 +1,102 @@
+package expo.modules.kotlin.events
+
+import android.os.Bundle
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.types.JSTypeConverter
+import java.lang.ref.WeakReference
+
+/**
+ * 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 KModuleEventEmitterWrapper(
+  private val moduleHolder: ModuleHolder,
+  legacyEventEmitter: expo.modules.core.interfaces.services.EventEmitter,
+  reactContextHolder: WeakReference<ReactApplicationContext>
+) : KEventEmitterWrapper(legacyEventEmitter, reactContextHolder) {
+  override fun emit(eventName: String, eventBody: Bundle?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  override fun emit(eventName: String, eventBody: WritableMap?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  override fun emit(eventName: String, eventBody: Record?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  override fun emit(eventName: String, eventBody: Map<*, *>?) {
+    checkIfEventWasExported(eventName)
+    super.emit(eventName, eventBody)
+  }
+
+  private fun checkIfEventWasExported(eventName: String) {
+    require(
+      moduleHolder
+        .definition
+        .eventsDefinition
+        ?.names
+        ?.contains(eventName) == true
+    ) { "Unsupported event: $eventName." }
+  }
+}
+
+open class KEventEmitterWrapper(
+  private val legacyEventEmitter: expo.modules.core.interfaces.services.EventEmitter,
+  private val reactContextHolder: WeakReference<ReactApplicationContext>
+) : EventEmitter, expo.modules.core.interfaces.services.EventEmitter by legacyEventEmitter {
+  private val deviceEventEmitter: RCTDeviceEventEmitter?
+    get() = reactContextHolder
+      .get()
+      ?.getJSModule(RCTDeviceEventEmitter::class.java)
+
+  private val uiEventDispatcher: EventDispatcher?
+    get() = reactContextHolder
+      .get()
+      ?.getNativeModule(UIManagerModule::class.java)
+      ?.eventDispatcher
+
+  override fun emit(eventName: String, eventBody: WritableMap?) {
+    deviceEventEmitter
+      ?.emit(eventName, eventBody)
+  }
+  override fun emit(eventName: String, eventBody: Record?) {
+    deviceEventEmitter
+      ?.emit(eventName, JSTypeConverter.convertToJSValue(eventBody))
+  }
+
+  override fun emit(eventName: String, eventBody: Map<*, *>?) {
+    deviceEventEmitter
+      ?.emit(eventName, JSTypeConverter.convertToJSValue(eventBody))
+  }
+
+  override fun emit(viewId: Int, eventName: String, eventBody: WritableMap?) {
+    uiEventDispatcher
+      ?.dispatchEvent(UIEvent(viewId, eventName, eventBody))
+  }
+
+  private class UIEvent(
+    private val viewId: Int,
+    private val eventName: String,
+    private val eventBody: WritableMap?
+  ) : com.facebook.react.uimanager.events.Event<UIEvent>(viewId) {
+    override fun getEventName(): String = eventName
+    override fun canCoalesce(): Boolean = false
+    override fun getCoalescingKey(): Short = 0
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+      rctEventEmitter.receiveEvent(viewId, eventName, eventBody)
+    }
+  }
+}

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

@@ -2,6 +2,7 @@ package expo.modules.kotlin.exception
 
 import com.facebook.react.bridge.ReadableType
 import java.util.*
+import kotlin.reflect.KProperty1
 import kotlin.reflect.KType
 
 /**
@@ -32,9 +33,11 @@ open class CodedException(
     /**
      * 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 {
+    @PublishedApi
+    internal fun inferCode(clazz: Class<*>): String {
       val name = requireNotNull(clazz.simpleName) { "Cannot infer code name from class name. We don't support anonymous classes." }
 
+      @Suppress("Deprecation")
       return "ERR_" + name
         .replace("(Exception)$".toRegex(), "")
         .replace("(.)([A-Z])".toRegex(), "$1_$2")
@@ -43,6 +46,21 @@ open class CodedException(
   }
 }
 
+/**
+ * Infers error code from the exception class name -
+ * e.g. the code of `ModuleNotFoundException` becomes `ERR_MODULE_NOT_FOUND`.
+ *
+ * Example:
+ * ```kt
+ * class NoPermissionException : CodedException()
+ * val errorCode = errorCodeOf<NoPermissionException>() // ERR_NO_PERMISSION
+ * ```
+ *
+ * **Note**: This works only if the exception class didn't overwrite the error code manually.
+ */
+inline fun <reified T : CodedException> errorCodeOf(): String =
+  CodedException.inferCode(T::class.java)
+
 internal class IncompatibleArgTypeException(
   argumentType: KType,
   desiredType: KType,
@@ -67,9 +85,15 @@ internal class MethodNotFoundException :
 internal class NullArgumentException :
   CodedException(message = "Cannot assigned null to not nullable type.")
 
+internal class FieldRequiredException(property: KProperty1<*, *>) :
+  CodedException(message = "Value for field '$property' is required, got nil")
+
 internal class UnexpectedException(val throwable: Throwable) :
   CodedException(message = throwable.toString(), throwable)
 
+internal class ValidationException(message: String) :
+  CodedException(message = message)
+
 /**
  * A base class for all exceptions used in `exceptionDecorator` function.
  */

package/android/src/main/java/expo/modules/kotlin/{methods/AnyMethod.kt → functions/AnyFunction.kt}

@@ -1,6 +1,7 @@
-package expo.modules.kotlin.methods
+package expo.modules.kotlin.functions
 
 import com.facebook.react.bridge.ReadableArray
+import expo.modules.kotlin.ModuleHolder
 import expo.modules.kotlin.Promise
 import expo.modules.kotlin.exception.ArgumentCastException
 import expo.modules.kotlin.exception.CodedException
@@ -10,22 +11,22 @@ import expo.modules.kotlin.iterator
 import expo.modules.kotlin.recycle
 import expo.modules.kotlin.types.AnyType
 
-abstract class AnyMethod(
+abstract class AnyFunction(
   protected val name: String,
   private val desiredArgsTypes: Array<AnyType>
 ) {
   @Throws(CodedException::class)
-  fun call(args: ReadableArray, promise: Promise) {
+  fun call(module: ModuleHolder, args: ReadableArray, promise: Promise) {
     if (desiredArgsTypes.size != args.size()) {
       throw InvalidArgsNumberException(args.size(), desiredArgsTypes.size)
     }
 
     val convertedArgs = convertArgs(args)
-    callImplementation(convertedArgs, promise)
+    callImplementation(module, convertedArgs, promise)
   }
 
   @Throws(CodedException::class)
-  internal abstract fun callImplementation(args: Array<out Any?>, promise: Promise)
+  internal abstract fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise)
 
   val argsCount get() = desiredArgsTypes.size
 

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

@@ -0,0 +1,15 @@
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+
+class AsyncFunction(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: (args: Array<out Any?>) -> Any?
+) : AnyFunction(name, argsType) {
+  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
+    promise.resolve(body(args))
+  }
+}

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

@@ -0,0 +1,61 @@
+@file:OptIn(ExperimentalStdlibApi::class)
+
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.types.toAnyType
+import kotlin.reflect.typeOf
+
+class AsyncFunctionBuilder(val name: String) {
+  @PublishedApi
+  internal var function: AnyFunction? = null
+
+  inline fun <reified R> suspendBody(crossinline block: suspend () -> R) {
+    function = AsyncSuspendFunction(name, arrayOf()) { block() }
+  }
+
+  inline fun <reified R, reified P0> suspendBody(crossinline block: suspend (p0: P0) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0) }
+  }
+
+  inline fun <reified R, reified P0, reified P1> suspendBody(crossinline block: suspend (p0: P0, p1: P1) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[0] as P1) }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(it[0] as P0, it[1] as P1, it[2] as P2) }
+  }
+
+  inline fun <reified R, reified P0, reified P1, reified P2, reified P3> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(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> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(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> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(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> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(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> suspendBody(crossinline block: suspend (p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) -> R) {
+    function = AsyncSuspendFunction(name, arrayOf(typeOf<P0>().toAnyType())) { block(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) }
+  }
+
+  internal fun build(): Pair<String, AnyFunction> {
+    return name to requireNotNull(function)
+  }
+}
+
+inline infix fun <reified R> AsyncFunctionBuilder.coroutine(crossinline block: suspend () -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6) -> R) = suspendBody(block)
+inline infix fun <reified R, reified P0, reified P1, reified P2, reified P3, reified P4, reified P5, reified P6, reified P7> AsyncFunctionBuilder.coroutine(crossinline block: suspend (P0, P1, P2, P3, P4, P5, P6, P7) -> R) = suspendBody(block)

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

@@ -0,0 +1,15 @@
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.types.AnyType
+
+class AsyncFunctionWithPromise(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: (args: Array<out Any?>, promise: Promise) -> Unit
+) : AnyFunction(name, argsType) {
+  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
+    body(args, promise)
+  }
+}

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

@@ -0,0 +1,36 @@
+package expo.modules.kotlin.functions
+
+import expo.modules.kotlin.ModuleHolder
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.FunctionCallException
+import expo.modules.kotlin.exception.UnexpectedException
+import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.types.AnyType
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+class AsyncSuspendFunction(
+  name: String,
+  argsType: Array<AnyType>,
+  private val body: suspend CoroutineScope.(args: Array<out Any?>) -> Any?
+) : AnyFunction(name, argsType) {
+  override fun callImplementation(holder: ModuleHolder, args: Array<out Any?>, promise: Promise) {
+    val scope = holder.module.coroutineScopeDelegate.value
+    scope.launch {
+      try {
+        val result = exceptionDecorator({ cause -> FunctionCallException(name, holder.name, cause) }) {
+          body.invoke(scope, args)
+        }
+        if (isActive) {
+          promise.resolve(result)
+        }
+      } catch (e: CodedException) {
+        promise.reject(e)
+      } catch (e: Throwable) {
+        promise.reject(UnexpectedException(e))
+      }
+    }
+  }
+}

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

@@ -1,7 +1,10 @@
 package expo.modules.kotlin.modules
 
 import android.os.Bundle
+import expo.modules.core.errors.ModuleDestroyedException
 import expo.modules.kotlin.AppContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancel
 
 abstract class Module {
   @Suppress("PropertyName")
@@ -12,11 +15,22 @@ abstract class Module {
   val appContext: AppContext
     get() = requireNotNull(_appContext) { "The module wasn't created! You can't access the app context." }
 
+  @Suppress("PropertyName")
+  @PublishedApi
+  internal lateinit var coroutineScopeDelegate: Lazy<CoroutineScope>
+  val coroutineScope get() = coroutineScopeDelegate.value
+
   fun sendEvent(name: String, body: Bundle?) {
     moduleEventEmitter?.emit(name, body)
   }
 
   abstract fun definition(): ModuleDefinitionData
+
+  internal fun cleanUp() {
+    if (coroutineScopeDelegate.isInitialized()) {
+      coroutineScope.cancel(ModuleDestroyedException())
+    }
+  }
 }
 
 @Suppress("FunctionName")