expo-modules-core 1.2.6 → 1.3.0

package/android/src/main/cpp/types/FrontendConverter.cpp

@@ -9,6 +9,7 @@
 #include "../JSIInteropModuleRegistry.h"
 #include "../JavaScriptObject.h"
 #include "../JavaScriptValue.h"
+#include "../JavaScriptFunction.h"
 #include "../javaclasses/Collections.h"
 
 #include "react/jni/ReadableNativeMap.h"
@@ -207,6 +208,25 @@ bool JavaScriptObjectFrontendConverter::canConvert(
   return value.isObject();
 }
 
+jobject JavaScriptFunctionFrontendConverter::convert(
+  jsi::Runtime &rt,
+  JNIEnv *env,
+  JSIInteropModuleRegistry *moduleRegistry,
+  const jsi::Value &value
+) const {
+  return JavaScriptFunction::newObjectCxxArgs(
+    moduleRegistry->runtimeHolder->weak_from_this(),
+    std::make_shared<jsi::Function>(value.getObject(rt).asFunction(rt))
+  ).release();
+}
+
+bool JavaScriptFunctionFrontendConverter::canConvert(
+  jsi::Runtime &rt,
+  const jsi::Value &value
+) const {
+  return value.isObject() && value.asObject(rt).isFunction(rt);
+}
+
 jobject UnknownFrontendConverter::convert(
   jsi::Runtime &rt,
   JNIEnv *env,
@@ -429,4 +449,42 @@ bool MapFrontendConverter::canConvert(
 ) const {
   return value.isObject();
 }
+
+jobject ViewTagFrontendConverter::convert(jsi::Runtime &rt, JNIEnv *env,
+                                          JSIInteropModuleRegistry *moduleRegistry,
+                                          const jsi::Value &value) const {
+  auto nativeTag = value.getObject(rt).getProperty(rt, "nativeTag");
+  if (nativeTag.isNull()) {
+    return nullptr;
+  }
+
+  auto viewTag = (int) nativeTag.getNumber();
+  auto &integerClass = JavaReferencesCache::instance()
+    ->getJClass("java/lang/Integer");
+  jmethodID integerConstructor = integerClass.getMethod("<init>", "(I)V");
+  return env->NewObject(integerClass.clazz, integerConstructor, viewTag);
+}
+
+bool ViewTagFrontendConverter::canConvert(jsi::Runtime &rt, const jsi::Value &value) const {
+  return value.isObject() && value.getObject(rt).hasProperty(rt, "nativeTag");
+}
+
+jobject SharedObjectIdConverter::convert(jsi::Runtime &rt, JNIEnv *env,
+                                         JSIInteropModuleRegistry *moduleRegistry,
+                                         const jsi::Value &value) const {
+  auto objectId = value.getObject(rt).getProperty(rt, "__expo_shared_object_id__");
+  if (objectId.isNull()) {
+    return nullptr;
+  }
+
+  auto viewTag = (int) objectId.getNumber();
+  auto &integerClass = JavaReferencesCache::instance()
+    ->getJClass("java/lang/Integer");
+  jmethodID integerConstructor = integerClass.getMethod("<init>", "(I)V");
+  return env->NewObject(integerClass.clazz, integerConstructor, viewTag);
+}
+
+bool SharedObjectIdConverter::canConvert(jsi::Runtime &rt, const jsi::Value &value) const {
+  return value.isObject() && value.getObject(rt).hasProperty(rt, "__expo_shared_object_id__");
+}
 } // namespace expo

package/android/src/main/cpp/types/FrontendConverter.h

@@ -205,6 +205,51 @@ public:
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
 };
 
+/**
+ * Converter from js function to [expo.modules.kotlin.jni.JavaScriptFunction].
+ */
+class JavaScriptFunctionFrontendConverter : public FrontendConverter {
+public:
+  jobject convert(
+    jsi::Runtime &rt,
+    JNIEnv *env,
+    JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value &value
+  ) const override;
+
+  bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+};
+
+/**
+ * Converter from js view object to int.
+ */
+class ViewTagFrontendConverter : public FrontendConverter {
+public:
+  jobject convert(
+    jsi::Runtime &rt,
+    JNIEnv *env,
+    JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value &value
+  ) const override;
+
+  bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+};
+
+/**
+ * Converter from js shared object to int.
+ */
+class SharedObjectIdConverter : public FrontendConverter {
+public:
+  jobject convert(
+    jsi::Runtime &rt,
+    JNIEnv *env,
+    JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value &value
+  ) const override;
+
+  bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
+};
+
 /**
  * Converter that always fails.
  * Used to not fail when the function is created.

package/android/src/main/cpp/types/FrontendConverterProvider.cpp

@@ -19,9 +19,12 @@ void FrontendConverterProvider::createConverters() {
   RegisterConverter(CppType::TYPED_ARRAY, TypedArrayFrontendConverter);
   RegisterConverter(CppType::JS_OBJECT, JavaScriptObjectFrontendConverter);
   RegisterConverter(CppType::JS_VALUE, JavaScriptValueFrontendConverter);
+  RegisterConverter(CppType::JS_FUNCTION, JavaScriptFunctionFrontendConverter);
   RegisterConverter(CppType::STRING, StringFrontendConverter);
   RegisterConverter(CppType::READABLE_MAP, ReadableNativeMapArrayFrontendConverter);
   RegisterConverter(CppType::READABLE_ARRAY, ReadableNativeArrayFrontendConverter);
+  RegisterConverter(CppType::VIEW_TAG, ViewTagFrontendConverter);
+  RegisterConverter(CppType::SHARED_OBJECT_ID, SharedObjectIdConverter);
 #undef RegisterConverter
 
   auto registerPolyConverter = [this](const std::vector<CppType> &types) {

package/android/src/main/cpp/types/JNIToJSIConverter.cpp

@@ -0,0 +1,88 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#include "JNIToJSIConverter.h"
+#include "../JavaReferencesCache.h"
+#include "../ObjectDeallocator.h"
+
+#include <react/jni/ReadableNativeMap.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <react/jni/WritableNativeArray.h>
+#include <react/jni/WritableNativeMap.h>
+
+namespace react = facebook::react;
+
+namespace expo {
+
+jsi::Value convert(
+  JSIInteropModuleRegistry *moduleRegistry,
+  JNIEnv *env,
+  jsi::Runtime &rt,
+  jni::local_ref<jobject> value
+) {
+  if (value == nullptr) {
+    return jsi::Value::undefined();
+  }
+  auto unpackedValue = value.get();
+  auto cache = JavaReferencesCache::instance();
+  if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/Double").clazz)) {
+    return {jni::static_ref_cast<jni::JDouble>(value)->value()};
+  }
+  if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/Integer").clazz)) {
+    return {jni::static_ref_cast<jni::JInteger>(value)->value()};
+  }
+  if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/Long").clazz)) {
+    return {(double) jni::static_ref_cast<jni::JLong>(value)->value()};
+  }
+  if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/String").clazz)) {
+    return jsi::String::createFromUtf8(
+      rt,
+      jni::static_ref_cast<jni::JString>(value)->toStdString()
+    );
+  }
+  if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/Boolean").clazz)) {
+    return {(bool) jni::static_ref_cast<jni::JBoolean>(value)->value()};
+  }
+  if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/Float").clazz)) {
+    return {(double) jni::static_ref_cast<jni::JFloat>(value)->value()};
+  }
+  if (env->IsInstanceOf(
+    unpackedValue,
+    cache->getJClass("com/facebook/react/bridge/WritableNativeArray").clazz
+  )) {
+    auto dynamic = jni::static_ref_cast<react::WritableNativeArray::javaobject>(value)
+      ->cthis()
+      ->consume();
+    return jsi::valueFromDynamic(rt, dynamic);
+  }
+  if (env->IsInstanceOf(
+    unpackedValue,
+    cache->getJClass("com/facebook/react/bridge/WritableNativeMap").clazz
+  )) {
+    auto dynamic = jni::static_ref_cast<react::WritableNativeMap::javaobject>(value)
+      ->cthis()
+      ->consume();
+    return jsi::valueFromDynamic(rt, dynamic);
+  }
+  if (env->IsInstanceOf(unpackedValue, JavaScriptModuleObject::javaClassStatic().get())) {
+    auto anonymousObject = jni::static_ref_cast<JavaScriptModuleObject::javaobject>(value)
+      ->cthis();
+    anonymousObject->jsiInteropModuleRegistry = moduleRegistry;
+    auto jsiObject = anonymousObject->getJSIObject(rt);
+
+    jni::global_ref<jobject> globalRef = jni::make_global(value);
+    std::shared_ptr<expo::ObjectDeallocator> deallocator = std::make_shared<ObjectDeallocator>(
+      [globalRef = std::move(globalRef)]() mutable {
+        globalRef.reset();
+      });
+
+    auto descriptor = JavaScriptObject::preparePropertyDescriptor(rt, 0);
+    descriptor.setProperty(rt, "value", jsi::Object::createFromHostObject(rt, deallocator));
+    JavaScriptObject::defineProperty(rt, jsiObject.get(), "__expo_object_deallocator__",
+                                     std::move(descriptor));
+
+    return jsi::Value(rt, *jsiObject);
+  }
+
+  return jsi::Value::undefined();
+}
+} // namespace expo

package/android/src/main/cpp/types/JNIToJSIConverter.h

@@ -0,0 +1,22 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include "../JSIInteropModuleRegistry.h"
+
+#include <fbjni/fbjni.h>
+#include <jsi/jsi.h>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+
+namespace expo {
+
+jsi::Value convert(
+  JSIInteropModuleRegistry *moduleRegistry,
+  JNIEnv *env,
+  jsi::Runtime &rt,
+  jni::local_ref<jobject> value
+);
+
+} // namespace expo

package/android/src/main/java/com/facebook/react/uimanager/ReactStylesDiffMapHelper.kt

@@ -0,0 +1,10 @@
+package com.facebook.react.uimanager
+
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Access the package private property declared inside of [ReactStylesDiffMap]
+ */
+fun ReactStylesDiffMap.getBackingMap(): ReadableMap {
+  return mBackingMap
+}

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

@@ -6,7 +6,6 @@ import android.content.Intent
 import android.os.Handler
 import android.os.HandlerThread
 import android.view.View
-import androidx.annotation.MainThread
 import androidx.annotation.UiThread
 import androidx.appcompat.app.AppCompatActivity
 import com.facebook.react.bridge.ReactApplicationContext
@@ -28,10 +27,7 @@ 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.AppContextActivityResultCaller
-import expo.modules.kotlin.activityresult.AppContextActivityResultContract
-import expo.modules.kotlin.activityresult.AppContextActivityResultFallbackCallback
-import expo.modules.kotlin.activityresult.AppContextActivityResultLauncher
+import expo.modules.kotlin.activityresult.DefaultAppContextActivityResultCaller
 import expo.modules.kotlin.defaultmodules.ErrorManagerModule
 import expo.modules.kotlin.defaultmodules.NativeModulesProxyModule
 import expo.modules.kotlin.events.EventEmitter
@@ -39,9 +35,11 @@ import expo.modules.kotlin.events.EventName
 import expo.modules.kotlin.events.KEventEmitterWrapper
 import expo.modules.kotlin.events.KModuleEventEmitterWrapper
 import expo.modules.kotlin.events.OnActivityResultPayload
+import expo.modules.kotlin.jni.JNIDeallocator
 import expo.modules.kotlin.jni.JSIInteropModuleRegistry
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.providers.CurrentActivityProvider
+import expo.modules.kotlin.sharedobjects.SharedObjectRegistry
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -49,25 +47,35 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.android.asCoroutineDispatcher
 import kotlinx.coroutines.cancel
 import java.io.File
-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, AppContextActivityResultCaller {
+) : CurrentActivityProvider {
   val registry = ModuleRegistry(WeakReference(this))
   private val reactLifecycleDelegate = ReactLifecycleDelegate(this)
 
   // We postpone creating the `JSIInteropModuleRegistry` to not load so files in unit tests.
   private lateinit var jsiInterop: JSIInteropModuleRegistry
 
+  internal val sharedObjectRegistry = SharedObjectRegistry()
+
   private val modulesQueueDispatcher = HandlerThread("expo.modules.AsyncFunctionQueue")
     .apply { start() }
     .looper.let { Handler(it) }
     .asCoroutineDispatcher()
 
+  /**
+   * A scope used to dispatch all background work.
+   */
+  val backgroundCoroutineScope = CoroutineScope(
+    Dispatchers.IO +
+      SupervisorJob() +
+      CoroutineName("expo.modules.BackgroundCoroutineScope")
+  )
+
   /**
    * A queue used to dispatch all async methods that are called via JSI.
    */
@@ -86,6 +94,7 @@ class AppContext(
   internal var legacyModulesProxyHolder: WeakReference<NativeModulesProxy>? = null
 
   private val activityResultsManager = ActivityResultsManager(this)
+  internal val appContextActivityResultCaller = DefaultAppContextActivityResultCaller(activityResultsManager)
 
   init {
     requireNotNull(reactContextHolder.get()) {
@@ -265,6 +274,8 @@ class AppContext(
     registry.cleanUp()
     modulesQueue.cancel(ContextDestroyedException())
     mainQueue.cancel(ContextDestroyedException())
+    backgroundCoroutineScope.cancel(ContextDestroyedException())
+    JNIDeallocator.deallocate()
     logger.info("✅ AppContext was destroyed")
   }
 
@@ -334,23 +345,5 @@ class AppContext(
       return activityProvider?.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
-  @Deprecated(message = "`registerForActivityResult` was deprecated. Please use `RegisterActivityContracts` component instead.")
-  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/FilteredIterator.kt

@@ -0,0 +1,37 @@
+package expo.modules.kotlin
+
+fun interface Filter<T> {
+  fun apply(type: T): Boolean
+}
+
+class FilteredIterator<E>(
+  private val iterator: Iterator<E>,
+  private val filter: Filter<E>
+) : Iterator<E> {
+  private var next: E? = null
+
+  init {
+    this.findNext()
+  }
+
+  override fun hasNext(): Boolean {
+    return next != null
+  }
+
+  override fun next(): E {
+    val returnValue = next!!
+    this.findNext()
+    return returnValue
+  }
+
+  private fun findNext() {
+    while (iterator.hasNext()) {
+      val next = iterator.next()
+      this.next = next
+      if (filter.apply(next)) {
+        return
+      }
+    }
+    next = null
+  }
+}

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

@@ -22,7 +22,7 @@ class KotlinInteropModuleRegistry(
   legacyModuleRegistry: expo.modules.core.ModuleRegistry,
   reactContext: WeakReference<ReactApplicationContext>
 ) {
-  internal val appContext = AppContext(modulesProvider, legacyModuleRegistry, reactContext)
+  val appContext = AppContext(modulesProvider, legacyModuleRegistry, reactContext)
 
   private val registry: ModuleRegistry
     get() = appContext.registry

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

@@ -1,6 +1,6 @@
 package expo.modules.kotlin
 
-import com.facebook.react.bridge.Arguments
+import android.view.View
 import com.facebook.react.bridge.ReadableArray
 import expo.modules.kotlin.events.BasicEventListener
 import expo.modules.kotlin.events.EventListenerWithPayload
@@ -12,6 +12,7 @@ import expo.modules.kotlin.exception.exceptionDecorator
 import expo.modules.kotlin.jni.JavaScriptModuleObject
 import expo.modules.kotlin.modules.Module
 import kotlinx.coroutines.launch
+import kotlin.reflect.KClass
 
 class ModuleHolder(val module: Module) {
   val definition = module.definition()
@@ -22,24 +23,36 @@ class ModuleHolder(val module: Module) {
    * Cached instance of HybridObject used by CPP to interact with underlying [expo.modules.kotlin.modules.Module] object.
    */
   val jsObject by lazy {
-    JavaScriptModuleObject(name)
-      .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)
-          }
+    val appContext = module.appContext
+
+    JavaScriptModuleObject(name).apply {
+      initUsingObjectDefinition(appContext, definition.objectDefinition)
+
+      val viewFunctions = definition.viewManagerDefinition?.asyncFunctions
+      if (viewFunctions?.isNotEmpty() == true) {
+        val viewPrototype = JavaScriptModuleObject("${name}_${definition.viewManagerDefinition?.viewType?.name}")
+        viewFunctions.forEach { function ->
+          function.attachToJSObject(appContext, viewPrototype)
+        }
+
+        registerViewPrototype(viewPrototype)
       }
+
+      definition.classData.forEach { clazz ->
+        val clazzModuleObject = JavaScriptModuleObject(clazz.name)
+          .initUsingObjectDefinition(module.appContext, clazz.objectDefinition)
+
+        val constructor = clazz.constructor
+        registerClass(
+          clazz.name,
+          clazzModuleObject,
+          constructor.takesOwner,
+          constructor.argsCount,
+          constructor.getCppRequiredTypes().toTypedArray(),
+          constructor.getJNIFunctionBody(clazz.name, appContext)
+        )
+      }
+    }
   }
 
   /**
@@ -85,12 +98,12 @@ class ModuleHolder(val module: Module) {
   fun registerContracts() {
     definition.registerContracts?.let {
       module.appContext.mainQueue.launch {
-        it.invoke(module.appContext)
+        it.invoke(module.appContext.appContextActivityResultCaller)
       }
     }
   }
 
-  fun cleanUp() {
-    module.cleanUp()
+  fun viewClass(): KClass<out View>? {
+    return definition.viewManagerDefinition?.viewType?.kotlin
   }
 }

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

@@ -6,7 +6,9 @@ import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
 import java.lang.ref.WeakReference
+import kotlin.reflect.full.declaredMemberProperties
 
 class ModuleRegistry(
   private val appContext: WeakReference<AppContext>
@@ -26,6 +28,17 @@ class ModuleRegistry(
     }
     holder.post(EventName.MODULE_CREATE)
     holder.registerContracts()
+    // The initial invocation of `declaredMemberProperties` appears to be slow,
+    // as Kotlin must deserialize metadata internally.
+    // This is a known issue that may be resolved by the new K2 compiler in the future.
+    // However, until then, we must find a way to address this problem.
+    // Therefore, we have decided to dispatch a lambda
+    // that invokes `declaredMemberProperties` during module creation.
+    holder.viewClass()?.let { viewType ->
+      appContext.get()?.backgroundCoroutineScope?.launch {
+        viewType.declaredMemberProperties
+      }
+    }
     registry[holder.name] = holder
   }
 
@@ -72,9 +85,6 @@ class ModuleRegistry(
   override fun iterator(): Iterator<ModuleHolder> = registry.values.iterator()
 
   fun cleanUp() {
-    forEach {
-      it.cleanUp()
-    }
     registry.clear()
     logger.info("✅ ModuleRegistry was destroyed")
   }

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

@@ -0,0 +1,21 @@
+package expo.modules.kotlin
+
+import android.os.Looper
+import expo.modules.kotlin.exception.Exceptions
+
+object Utils {
+  @Suppress("UseExpressionBody")
+  inline fun assertMainThread() {
+    if (Thread.currentThread() !== Looper.getMainLooper().thread) {
+      throw Exceptions.IncorrectThreadException(
+        Thread.currentThread().name,
+        Looper.getMainLooper().thread.name
+      )
+    }
+  }
+}
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun AppContext?.toStrongReference(): AppContext {
+  return this ?: throw Exceptions.AppContextLost()
+}

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

@@ -1,6 +1,8 @@
 package expo.modules.kotlin.activityresult
 
+import android.app.Activity
 import androidx.annotation.MainThread
+import expo.modules.kotlin.AppContext
 import java.io.Serializable
 
 /**
@@ -20,6 +22,24 @@ interface AppContextActivityResultCaller {
   @MainThread
   suspend fun <I : Serializable, O> registerForActivityResult(
     contract: AppContextActivityResultContract<I, O>,
-    fallbackCallback: AppContextActivityResultFallbackCallback<I, O>,
+    fallbackCallback: AppContextActivityResultFallbackCallback<I, O> = AppContextActivityResultFallbackCallback { _, _ -> /* NOOP */ },
   ): AppContextActivityResultLauncher<I, O>
 }
+
+internal class DefaultAppContextActivityResultCaller(
+  private val activityResultsManager: ActivityResultsManager
+) : 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).
+   */
+  override suspend fun <I : Serializable, O> registerForActivityResult(
+    contract: AppContextActivityResultContract<I, O>,
+    fallbackCallback: AppContextActivityResultFallbackCallback<I, O>
+  ): AppContextActivityResultLauncher<I, O> {
+    return activityResultsManager.registerForActivityResult(contract, fallbackCallback)
+  }
+}