expo-modules-core 0.9.2 → 0.11.1

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

@@ -0,0 +1,18 @@
+package expo.modules.kotlin
+
+/**
+ * Simple iterator that will merge two other iterators.
+ */
+class ConcatIterator<T>(
+  private val first: Iterator<T>,
+  private val second: Iterator<T>
+) : Iterator<T> {
+  override fun hasNext(): Boolean = first.hasNext() || second.hasNext()
+
+  override fun next(): T =
+    if (first.hasNext()) {
+      first.next()
+    } else {
+      second.next()
+    }
+}

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

@@ -41,26 +41,25 @@ class KotlinInteropModuleRegistry(
   }
 
   fun exportedModulesConstants(): Map<ModuleName, ModuleConstants> {
-    return registry
-      .map { holder ->
-        holder.name to holder.definition.constantsProvider()
-      }
-      .toMap()
+    return registry.associate { holder ->
+      holder.name to holder.definition.constantsProvider()
+    }
   }
 
   fun exportMethods(exportKey: (String, List<ModuleMethodInfo>) -> Unit = { _, _ -> }): Map<ModuleName, List<ModuleMethodInfo>> {
-    return registry
-      .map { holder ->
-        val methodsInfo = holder.definition.methods.map { (name, method) ->
+    return registry.associate { holder ->
+      val methodsInfo = holder
+        .definition
+        .asyncFunctions
+        .map { (name, method) ->
           mapOf(
             "name" to name,
             "argumentsCount" to method.argsCount
           )
         }
-        exportKey(holder.name, methodsInfo)
-        holder.name to methodsInfo
-      }
-      .toMap()
+      exportKey(holder.name, methodsInfo)
+      holder.name to methodsInfo
+    }
   }
 
   fun exportViewManagers(): List<ViewManager<*, *>> {
@@ -110,4 +109,8 @@ class KotlinInteropModuleRegistry(
   fun onDestroy() {
     appContext.onDestroy()
   }
+
+  fun installJSIInterop() {
+    appContext.installJSIInterop()
+  }
 }

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

@@ -1,5 +1,6 @@
 package expo.modules.kotlin
 
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableArray
 import expo.modules.kotlin.events.BasicEventListener
 import expo.modules.kotlin.events.EventListenerWithPayload
@@ -8,19 +9,60 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.exception.FunctionCallException
 import expo.modules.kotlin.exception.MethodNotFoundException
 import expo.modules.kotlin.exception.exceptionDecorator
+import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ProcessedModuleDefinition
 
 class ModuleHolder(val module: Module) {
-  val definition = module.definition()
+  val definition = ProcessedModuleDefinition(module.definition(), this)
+
   val name get() = definition.name
 
+  /**
+   * Cached instance of HybridObject used by CPP to interact with underlying [expo.modules.kotlin.modules.Module] object.
+   */
+  val jsObject by lazy {
+    JavaScriptModuleObject()
+      .apply {
+        val constants = definition.constantsProvider()
+        val convertedConstants = Arguments.makeNativeMap(constants)
+        exportConstants(convertedConstants)
+
+        definition
+          .functions
+          .forEach { function ->
+            function.attachToJSObject(module.appContext, this)
+          }
+
+        definition
+          .properties
+          .forEach { (_, prop) ->
+            prop.attachToJSObject(this)
+          }
+      }
+  }
+
+  /**
+   * Invokes a function with promise. Is used in the bridge implementation of the Sweet API.
+   */
   fun call(methodName: String, args: ReadableArray, promise: Promise) = exceptionDecorator({
     FunctionCallException(methodName, definition.name, it)
   }) {
-    val method = definition.methods[methodName]
+    val method = definition.asyncFunctions[methodName]
+      ?: throw MethodNotFoundException()
+
+    method.call(args, promise)
+  }
+
+  /**
+   * Invokes a function without promise.
+   * `callSync` was added only for test purpose and shouldn't be used anywhere else.
+   */
+  fun callSync(methodName: String, args: ReadableArray): Any? {
+    val method = definition.syncFunctions[methodName]
       ?: throw MethodNotFoundException()
 
-    method.call(this, args, promise)
+    return method.call(args)
   }
 
   fun post(eventName: EventName) {

package/android/src/main/java/expo/modules/kotlin/activityaware/AppCompatActivityAware.kt

@@ -0,0 +1,49 @@
+package expo.modules.kotlin.activityaware
+
+import android.app.Activity
+import androidx.appcompat.app.AppCompatActivity
+import expo.modules.kotlin.AppContext
+import kotlinx.coroutines.suspendCancellableCoroutine
+
+/**
+ * Similar to [androidx.activity.contextaware.ContextAware]
+ *
+ * A [AppCompatActivityAware] class is associated with a [AppCompatActivity] sometime after
+ * the [Activity] is passed down to the [AppContext] in [AppContext.onHostResume].
+ * By adding a [OnActivityAvailableListener] you can receive a callback for that event.
+ */
+interface AppCompatActivityAware {
+  /**
+   * Adds a listener waiting for Activity to become available.
+   * If Activity is available when listener is being added it will be immediately called.
+   */
+  fun addOnActivityAvailableListener(listener: OnActivityAvailableListener)
+
+  fun removeOnActivityAvailableListener(listener: OnActivityAvailableListener)
+}
+
+/**
+ * Similar to [androidx.activity.contextaware.ContextAware] from `androidx.activity:activity-kts`
+ *
+ * Run [onActivityAvailable] when the [AppCompatActivity] becomes available and resume with the result.
+ *
+ * If the [AppCompatActivity] is already available, [onActivityAvailable] will be synchronously
+ * called on the current coroutine context. Otherwise, [onActivityAvailable] will be called on the
+ * the UI thread immediately when the [Activity] becomes available.
+ *
+ * No matter how many times [Activity] will become available callback would be called only once.
+ */
+suspend inline fun <R> AppCompatActivityAware.withActivityAvailable(
+  crossinline onActivityAvailable: (AppCompatActivity) -> R
+): R = suspendCancellableCoroutine { continuation ->
+  val listener = object : OnActivityAvailableListener {
+    override fun onActivityAvailable(activity: AppCompatActivity) {
+      removeOnActivityAvailableListener(this)
+      continuation.resumeWith(runCatching { onActivityAvailable(activity) })
+    }
+  }
+  addOnActivityAvailableListener(listener)
+  continuation.invokeOnCancellation {
+    removeOnActivityAvailableListener(listener)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/activityaware/AppCompatActivityAwareHelper.kt

@@ -0,0 +1,43 @@
+package expo.modules.kotlin.activityaware
+
+import androidx.appcompat.app.AppCompatActivity
+import java.lang.ref.WeakReference
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Similar to [androidx.activity.contextaware.ContextAwareHelper]
+ *
+ * Helper class for implementing [AppCompatActivityAware].
+ */
+class AppCompatActivityAwareHelper : AppCompatActivityAware {
+  val listeners = CopyOnWriteArrayList<OnActivityAvailableListener>()
+
+  var activityReference = WeakReference<AppCompatActivity>(null)
+
+  fun dispatchOnActivityAvailable(activity: AppCompatActivity) {
+    this.activityReference = WeakReference(activity)
+
+    activity.runOnUiThread {
+      for (listener in listeners) {
+        listener.onActivityAvailable(activity)
+      }
+    }
+  }
+
+  // region AppCompatActivityAware
+
+  override fun addOnActivityAvailableListener(listener: OnActivityAvailableListener) {
+    listeners.add(listener)
+    activityReference.get()?.let { activity ->
+      activity.runOnUiThread {
+        listener.onActivityAvailable(activity)
+      }
+    }
+  }
+
+  override fun removeOnActivityAvailableListener(listener: OnActivityAvailableListener) {
+    listeners.remove(listener)
+  }
+
+  // endregion
+}

package/android/src/main/java/expo/modules/kotlin/activityaware/OnActivityAvailableListener.kt

@@ -0,0 +1,18 @@
+package expo.modules.kotlin.activityaware
+
+import androidx.annotation.UiThread
+import androidx.appcompat.app.AppCompatActivity
+
+/**
+ * Similar to [androidx.activity.contextaware.OnContextAvailableListener]
+ *
+ * Listener for receiving a callback at the first moment a [AppCompatActivity] is made
+ * available to the [AppCompatActivityAware] class.
+ */
+fun interface OnActivityAvailableListener {
+  /**
+   * This callback will be called on UI thread.
+   */
+  @UiThread
+  fun onActivityAvailable(activity: AppCompatActivity)
+}

package/android/src/main/java/expo/modules/kotlin/activityresult/ActivityResultsManager.kt

@@ -0,0 +1,99 @@
+@file:OptIn(DelicateCoroutinesApi::class)
+
+package expo.modules.kotlin.activityresult
+
+import android.app.Activity
+import android.content.Intent
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.Lifecycle
+import expo.modules.kotlin.AppContext
+import expo.modules.kotlin.activityaware.AppCompatActivityAware
+import expo.modules.kotlin.activityaware.AppCompatActivityAwareHelper
+import expo.modules.kotlin.activityaware.OnActivityAvailableListener
+import expo.modules.kotlin.activityaware.withActivityAvailable
+import expo.modules.kotlin.providers.CurrentActivityProvider
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import java.io.Serializable
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Manager class that takes care of proper communication with [AppContextActivityResultRegistry]
+ * It also monitors the needed lifecycle state using [AppCompatActivityAwareHelper]
+ */
+class ActivityResultsManager(
+  currentActivityProvider: CurrentActivityProvider
+) : AppContextActivityResultCaller, AppCompatActivityAware {
+  /**
+   * Due to the fact that [AppContext] is not coupled directly with the [Activity]'s lifecycle
+   * it's impossible to subscribe all [Lifecycle]'s events properly.
+   * That forces us to create our own [AppContextActivityResultRegistry].
+   */
+  private val registry = AppContextActivityResultRegistry(currentActivityProvider)
+  private val nextLocalRequestCode = AtomicInteger()
+
+  /**
+   * Helper property that allows for waiting for [Activity] creation.
+   * It is useful when some Module wants to register itself before the current [Activity] is made available.
+   */
+  private val activityAwareHelper = AppCompatActivityAwareHelper()
+
+  init {
+    GlobalScope.launch {
+      withActivityAvailable { activity ->
+        registry.restoreInstanceState(activity)
+      }
+    }
+  }
+
+  // region Lifecycle
+
+  fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    registry.dispatchResult(requestCode, resultCode, data)
+  }
+
+  /**
+   * This function is called every time the [Activity] is resumed.
+   * If you want to add some mechanism that fires only once (similar to how [Activity.onCreate] works),
+   * then use `init` block with [withActivityAvailable].
+   */
+  fun onHostResume(activity: AppCompatActivity) {
+    activityAwareHelper.dispatchOnActivityAvailable(activity)
+  }
+
+  fun onHostDestroy(activity: AppCompatActivity) {
+    registry.persistInstanceState(activity)
+  }
+
+  // endregion
+
+  // region AppContextActivityResultCaller
+
+  override suspend fun <I : Serializable, O> registerForActivityResult(
+    contract: AppContextActivityResultContract<I, O>,
+    fallbackCallback: AppContextActivityResultFallbackCallback<I, O>
+  ): AppContextActivityResultLauncher<I, O> =
+    withActivityAvailable { activity ->
+      registry.register(
+        "AppContext_rq#${nextLocalRequestCode.getAndIncrement()}",
+        activity,
+        contract,
+        fallbackCallback
+      )
+    }
+
+  // endregion
+
+  // region ActivityAware
+
+  override fun addOnActivityAvailableListener(listener: OnActivityAvailableListener) {
+    activityAwareHelper.addOnActivityAvailableListener(listener)
+  }
+
+  override fun removeOnActivityAvailableListener(listener: OnActivityAvailableListener) {
+    activityAwareHelper.removeOnActivityAvailableListener(listener)
+  }
+
+  // endregion
+}

package/android/src/main/java/expo/modules/kotlin/activityresult/AppContextActivityResultCaller.kt

@@ -0,0 +1,25 @@
+package expo.modules.kotlin.activityresult
+
+import androidx.annotation.MainThread
+import java.io.Serializable
+
+/**
+ * This interface is directly based on [androidx.activity.result.ActivityResultCaller], but due to incompatibility
+ * of ReactNative and Android's [androidx.lifecycle.Lifecycle] it needed to be adapted.
+ * For more information how to use it read [androidx.activity.result.ActivityResultCaller] from `androidx.activity:activity:1.4.0`
+ * or even better from `androidx.activity:activity-ktx:1.4.0`.
+ *
+ * @see [androidx.activity.result.ActivityResultCaller]
+ */
+interface AppContextActivityResultCaller {
+  /**
+   * @see [androidx.activity.result.ActivityResultCaller.registerForActivityResult] from `androidx.activity:activity-ktx:1.4.0`.
+   * @param I - input, it is preserved across Activity calls and is delivered to fallback callback
+   * @param O - output
+   */
+  @MainThread
+  suspend fun <I : Serializable, O> registerForActivityResult(
+    contract: AppContextActivityResultContract<I, O>,
+    fallbackCallback: AppContextActivityResultFallbackCallback<I, O>,
+  ): AppContextActivityResultLauncher<I, O>
+}

package/android/src/main/java/expo/modules/kotlin/activityresult/AppContextActivityResultContract.kt

@@ -0,0 +1,27 @@
+package expo.modules.kotlin.activityresult
+
+import android.content.Context
+import android.content.Intent
+import java.io.Serializable
+
+/**
+ * A contract specifying that an activity can be called with an input of type [I] and produce an output of type [O].
+ *
+ * Makes calling an activity for result type-safe.
+ *
+ * This interface differs from the original in terms of providing `input` parameter in the [parseResult] method.
+ *
+ * @see androidx.activity.result.contract.ActivityResultContract
+ */
+interface AppContextActivityResultContract<I : Serializable, O> {
+  /**
+   * Create an intent that can be used for [android.app.Activity.startActivityForResult].
+   */
+  fun createIntent(context: Context, input: I): Intent
+
+  /**
+   * Convert result obtained from [android.app.Activity.onActivityResult] to [O].
+   * @param input the very same input object that is used in [createIntent] method. You can use it to add additional information to constructed result.
+   */
+  fun parseResult(input: I, resultCode: Int, intent: Intent?): O
+}

package/android/src/main/java/expo/modules/kotlin/activityresult/AppContextActivityResultFallbackCallback.kt

@@ -0,0 +1,17 @@
+package expo.modules.kotlin.activityresult
+
+import java.io.Serializable
+
+/**
+ * Interface for fallback callback that has to be registered at the very beginning of module's lifecycle
+ * in order to deliver all results in case launching [android.app.Activity] is killed.
+ *
+ * @see [androidx.activity.result.ActivityResultCallback]
+ */
+fun interface AppContextActivityResultFallbackCallback<I : Serializable, O> {
+  /**
+   * @param input parameters used to construct Intent that launched the operation
+   * @param result output constructed by the associated [AppContextActivityResultContract]
+   */
+  fun onActivityResult(input: I, result: O)
+}

package/android/src/main/java/expo/modules/kotlin/activityresult/AppContextActivityResultLauncher.kt

@@ -0,0 +1,30 @@
+package expo.modules.kotlin.activityresult
+
+import androidx.activity.result.ActivityResultCallback
+import androidx.activity.result.contract.ActivityResultContract
+import java.io.Serializable
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+/**
+ * A launcher for a previously-[AppContextActivityResultCaller.registerForActivityResult] prepared call
+ * to start the process of executing an [ActivityResultContract]
+ *
+ * @param I type of the input required to launch, it also is preserved and delivered in fallback callback
+ * @param O result type
+ *
+ * @see [androidx.activity.result.ActivityResultLauncher]
+ */
+abstract class AppContextActivityResultLauncher<I : Serializable, O> {
+  /**
+   * @param input This would be persisted and restored upon possible Activity destruction by the system
+   * to keep context of launching the mechanism.
+   */
+  abstract fun launch(input: I, callback: ActivityResultCallback<O>)
+
+  suspend fun launch(input: I): O = suspendCoroutine { continuation ->
+    launch(input) { output -> continuation.resume(output) }
+  }
+
+  abstract val contract: AppContextActivityResultContract<I, O>
+}