expo-modules-core 0.10.0 → 0.11.2

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

@@ -5,6 +5,7 @@ package expo.modules.kotlin
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
+import androidx.annotation.MainThread
 import androidx.appcompat.app.AppCompatActivity
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
@@ -19,6 +20,11 @@ import expo.modules.interfaces.imageloader.ImageLoaderInterface
 import expo.modules.interfaces.permissions.Permissions
 import expo.modules.interfaces.sensors.SensorServiceInterface
 import expo.modules.interfaces.taskManager.TaskManagerInterface
+import expo.modules.kotlin.activityresult.ActivityResultsManager
+import expo.modules.kotlin.activityresult.AppContextActivityResultFallbackCallback
+import expo.modules.kotlin.activityresult.AppContextActivityResultCaller
+import expo.modules.kotlin.activityresult.AppContextActivityResultContract
+import expo.modules.kotlin.activityresult.AppContextActivityResultLauncher
 import expo.modules.kotlin.defaultmodules.ErrorManagerModule
 import expo.modules.kotlin.events.EventEmitter
 import expo.modules.kotlin.events.EventName
@@ -34,45 +40,64 @@ import kotlinx.coroutines.DelicateCoroutinesApi
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.newSingleThreadContext
+import java.io.Serializable
 import java.lang.ref.WeakReference
 
 class AppContext(
   modulesProvider: ModulesProvider,
   val legacyModuleRegistry: expo.modules.core.ModuleRegistry,
   private val reactContextHolder: WeakReference<ReactApplicationContext>
-) : CurrentActivityProvider {
+) : CurrentActivityProvider, AppContextActivityResultCaller {
   val registry = ModuleRegistry(WeakReference(this)).apply {
-    register(ErrorManagerModule())
-    register(modulesProvider)
   }
   private val reactLifecycleDelegate = ReactLifecycleDelegate(this)
+
   // We postpone creating the `JSIInteropModuleRegistry` to not load so files in unit tests.
   private lateinit var jsiInterop: JSIInteropModuleRegistry
+
+  /**
+   * A queue used to dispatch all async methods that are called via JSI.
+   */
   internal val modulesQueue = CoroutineScope(
+    // TODO(@lukmccall): maybe it will be better to use a thread pool
     newSingleThreadContext("ExpoModulesCoreQueue") +
       SupervisorJob() +
       CoroutineName("ExpoModulesCoreCoroutineQueue")
   )
 
+  private val activityResultsManager = ActivityResultsManager(this)
+
   init {
     requireNotNull(reactContextHolder.get()) {
       "The app context should be created with valid react context."
     }.apply {
       addLifecycleEventListener(reactLifecycleDelegate)
       addActivityEventListener(reactLifecycleDelegate)
+
+      // Registering modules has to happen at the very end of `AppContext` creation. Some modules need to access
+      // `AppContext` during their initialisation (or during `OnCreate` method), so we need to ensure all `AppContext`'s
+      // properties are initialized first. Not having that would trigger NPE.
+      registry.register(ErrorManagerModule())
+      registry.register(modulesProvider)
     }
   }
 
+  /**
+   * Initializes a JSI part of the module registry.
+   * It will be a NOOP if the remote debugging was activated.
+   */
   fun installJSIInterop() {
     jsiInterop = JSIInteropModuleRegistry(this)
     val reactContext = reactContextHolder.get() ?: return
-    reactContext.javaScriptContextHolder?.get()?.let {
-      jsiInterop.installJSI(
-        it,
-        reactContext.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl,
-        reactContext.catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
-      )
-    }
+    reactContext.javaScriptContextHolder?.get()
+      ?.takeIf { it != 0L }
+      ?.let {
+        jsiInterop.installJSI(
+          it,
+          reactContext.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl,
+          reactContext.catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
+        )
+      }
   }
 
   /**
@@ -185,6 +210,11 @@ class AppContext(
   }
 
   fun onHostResume() {
+    activityResultsManager.onHostResume(
+      requireNotNull(currentActivity) {
+        "Current Activity is not available at this moment. This is an invalid state and this should never happen"
+      }
+    )
     registry.post(EventName.ACTIVITY_ENTERS_FOREGROUND)
   }
 
@@ -193,10 +223,16 @@ class AppContext(
   }
 
   fun onHostDestroy() {
+    activityResultsManager.onHostDestroy(
+      requireNotNull(currentActivity) {
+        "Current Activity is not available at this moment. This is an invalid state and this should never happen"
+      }
+    )
     registry.post(EventName.ACTIVITY_DESTROYS)
   }
 
   fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    activityResultsManager.onActivityResult(activity, requestCode, resultCode, data)
     registry.post(
       EventName.ON_ACTIVITY_RESULT,
       activity,
@@ -228,5 +264,22 @@ class AppContext(
       return currentActivity
     }
 
+// endregion
+
+// region AppContextActivityResultCaller
+
+  /**
+   * For the time being [fallbackCallback] is not working.
+   * There are some problems with saving and restoring the state of [activityResultsManager]
+   * connected with [Activity]'s lifecycle and [AppContext] lifespan. So far, we've failed with identifying
+   * what parts of the application outlives the Activity destruction (especially [AppContext] and other [Bridge]-related parts).
+   */
+  @MainThread
+  override suspend fun <I : Serializable, O> registerForActivityResult(
+    contract: AppContextActivityResultContract<I, O>,
+    fallbackCallback: AppContextActivityResultFallbackCallback<I, O>
+  ): AppContextActivityResultLauncher<I, O> =
+    activityResultsManager.registerForActivityResult(contract, fallbackCallback)
+
 // endregion
 }

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

@@ -33,6 +33,12 @@ class ModuleHolder(val module: Module) {
           .forEach { function ->
             function.attachToJSObject(module.appContext, this)
           }
+
+        definition
+          .properties
+          .forEach { (_, prop) ->
+            prop.attachToJSObject(this)
+          }
       }
   }
 

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>
+}