expo-modules-core 0.9.2 → 0.11.1

package/android/src/main/cpp/MethodMetadata.cpp

@@ -0,0 +1,340 @@
+#include "MethodMetadata.h"
+#include "JSIInteropModuleRegistry.h"
+#include "JavaScriptValue.h"
+#include "JavaScriptObject.h"
+#include "CachedReferencesRegistry.h"
+
+#include <utility>
+
+#include "react/jni/ReadableNativeMap.h"
+#include "react/jni/ReadableNativeArray.h"
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+
+// Modified version of the RN implementation
+// https://github.com/facebook/react-native/blob/7dceb9b63c0bfd5b13bf6d26f9530729506e9097/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp#L57
+jni::local_ref<react::JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
+  jsi::Function &&function,
+  jsi::Runtime &rt,
+  std::shared_ptr<react::CallInvoker> jsInvoker
+) {
+  auto weakWrapper = react::CallbackWrapper::createWeak(std::move(function), rt,
+                                                        std::move(jsInvoker));
+
+  // This needs to be a shared_ptr because:
+  // 1. It cannot be unique_ptr. std::function is copyable but unique_ptr is
+  // not.
+  // 2. It cannot be weak_ptr since we need this object to live on.
+  // 3. It cannot be a value, because that would be deleted as soon as this
+  // function returns.
+  auto callbackWrapperOwner =
+    std::make_shared<react::RAIICallbackWrapperDestroyer>(weakWrapper);
+
+  std::function<void(folly::dynamic)> fn =
+    [weakWrapper, callbackWrapperOwner, wrapperWasCalled = false](
+      folly::dynamic responses) mutable {
+      if (wrapperWasCalled) {
+        throw std::runtime_error(
+          "callback 2 arg cannot be called more than once");
+      }
+
+      auto strongWrapper = weakWrapper.lock();
+      if (!strongWrapper) {
+        return;
+      }
+
+      strongWrapper->jsInvoker().invokeAsync(
+        [weakWrapper, callbackWrapperOwner, responses]() mutable {
+          auto strongWrapper2 = weakWrapper.lock();
+          if (!strongWrapper2) {
+            return;
+          }
+
+          jsi::Value args =
+            jsi::valueFromDynamic(strongWrapper2->runtime(), responses);
+          auto argsArray = args.getObject(strongWrapper2->runtime())
+            .asArray(strongWrapper2->runtime());
+          jsi::Value arg = argsArray.getValueAtIndex(strongWrapper2->runtime(), 0);
+
+          strongWrapper2->callback().call(
+            strongWrapper2->runtime(),
+            (const jsi::Value *) &arg,
+            (size_t) 1
+          );
+
+          callbackWrapperOwner.reset();
+        });
+
+      wrapperWasCalled = true;
+    };
+
+  return react::JCxxCallbackImpl::newObjectCxxArgs(fn);
+}
+
+std::vector<jvalue> MethodMetadata::convertJSIArgsToJNI(
+  JSIInteropModuleRegistry *moduleRegistry,
+  JNIEnv *env,
+  jsi::Runtime &rt,
+  const jsi::Value *args,
+  size_t count
+) {
+  std::vector<jvalue> result(count);
+
+  for (unsigned int argIndex = 0; argIndex < count; argIndex++) {
+    const jsi::Value *arg = &args[argIndex];
+    jvalue *jarg = &result[argIndex];
+    int desiredType = desiredTypes[argIndex];
+
+    if (desiredType & CppType::JS_VALUE) {
+      jarg->l = JavaScriptValue::newObjectCxxArgs(
+        moduleRegistry->runtimeHolder->weak_from_this(),
+        // TODO(@lukmccall): make sure that copy here is necessary
+        std::make_shared<jsi::Value>(jsi::Value(rt, *arg))
+      ).release();
+    } else if (desiredType & CppType::JS_OBJECT) {
+      jarg->l = JavaScriptObject::newObjectCxxArgs(
+        moduleRegistry->runtimeHolder->weak_from_this(),
+        std::make_shared<jsi::Object>(arg->getObject(rt))
+      ).release();
+    } else if (arg->isNull() || arg->isUndefined()) {
+      jarg->l = nullptr;
+    } else if (arg->isNumber()) {
+      auto &doubleClass = CachedReferencesRegistry::instance()
+        ->getJClass("java/lang/Double");
+      jmethodID doubleConstructor = doubleClass.getMethod("<init>", "(D)V");
+      jarg->l = env->NewObject(doubleClass.clazz, doubleConstructor, arg->getNumber());
+    } else if (arg->isBool()) {
+      auto &booleanClass = CachedReferencesRegistry::instance()
+        ->getJClass("java/lang/Boolean");
+      jmethodID booleanConstructor = booleanClass.getMethod("<init>", "(Z)V");
+      jarg->l = env->NewObject(booleanClass.clazz, booleanConstructor, arg->getBool());
+    } else if (arg->isString()) {
+      jarg->l = env->NewStringUTF(arg->getString(rt).utf8(rt).c_str());
+    } else if (arg->isObject()) {
+      const jsi::Object object = arg->getObject(rt);
+
+      // TODO(@lukmccall): stop using dynamic
+      auto dynamic = jsi::dynamicFromValue(rt, *arg);
+      if (arg->getObject(rt).isArray(rt)) {
+        jarg->l = react::ReadableNativeArray::newObjectCxxArgs(std::move(dynamic)).release();
+      } else {
+        jarg->l = react::ReadableNativeMap::createWithContents(std::move(dynamic)).release();
+      }
+    } else {
+      // TODO(@lukmccall): throw an exception
+      jarg->l = nullptr;
+    }
+  }
+
+  return result;
+}
+
+MethodMetadata::MethodMetadata(
+  std::string name,
+  int args,
+  bool isAsync,
+  std::unique_ptr<int[]> desiredTypes,
+  jni::global_ref<jobject> &&jBodyReference
+) : name(std::move(name)),
+    args(args),
+    isAsync(isAsync),
+    desiredTypes(std::move(desiredTypes)),
+    jBodyReference(std::move(jBodyReference)) {}
+
+std::shared_ptr<jsi::Function> MethodMetadata::toJSFunction(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry
+) {
+  if (body == nullptr) {
+    if (isAsync) {
+      body = std::make_shared<jsi::Function>(toAsyncFunction(runtime, moduleRegistry));
+    } else {
+      body = std::make_shared<jsi::Function>(toSyncFunction(runtime, moduleRegistry));
+    }
+  }
+
+  return body;
+}
+
+jsi::Function MethodMetadata::toSyncFunction(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry
+) {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, name),
+    args,
+    [this, moduleRegistry](
+      jsi::Runtime &rt,
+      const jsi::Value &thisValue,
+      const jsi::Value *args,
+      size_t count
+    ) -> jsi::Value {
+      return this->callSync(
+        rt,
+        moduleRegistry,
+        args,
+        count
+      );
+    });
+}
+
+jsi::Value MethodMetadata::callSync(
+  jsi::Runtime &rt,
+  JSIInteropModuleRegistry *moduleRegistry,
+  const jsi::Value *args,
+  size_t count
+) {
+  if (this->jBodyReference == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  JNIEnv *env = jni::Environment::current();
+
+  /**
+   * This will push a new JNI stack frame for the LocalReferences in this
+   * function call. When the stack frame for this lambda is popped,
+   * all LocalReferences are deleted.
+   */
+  jni::JniLocalScope scope(env, (int) count);
+
+  std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count);
+
+  // TODO(@lukmccall): Remove this temp array
+  auto tempArray = jni::JArrayClass<jobject>::newArray(count);
+  for (size_t i = 0; i < convertedArgs.size(); i++) {
+    tempArray->setElement(i, convertedArgs[i].l);
+  }
+
+  // Cast in this place is safe, cause we know that this function is promise-less.
+  auto syncFunction = jni::static_ref_cast<JNIFunctionBody>(this->jBodyReference);
+  auto result = syncFunction->invoke(
+    std::move(tempArray)
+  );
+
+  if (result == nullptr) {
+    return jsi::Value::undefined();
+  }
+
+  return jsi::valueFromDynamic(rt, result->cthis()->consume())
+    .asObject(rt)
+    .asArray(rt)
+    .getValueAtIndex(rt, 0);
+}
+
+jsi::Function MethodMetadata::toAsyncFunction(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry
+) {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, name),
+    args,
+    [this, moduleRegistry](
+      jsi::Runtime &rt,
+      const jsi::Value &thisValue,
+      const jsi::Value *args,
+      size_t count
+    ) -> jsi::Value {
+      JNIEnv *env = jni::Environment::current();
+
+      /**
+       * This will push a new JNI stack frame for the LocalReferences in this
+       * function call. When the stack frame for this lambda is popped,
+       * all LocalReferences are deleted.
+       */
+      jni::JniLocalScope scope(env, (int) count);
+
+      std::vector<jvalue> convertedArgs = convertJSIArgsToJNI(moduleRegistry, env, rt, args, count);
+
+      // TODO(@lukmccall): Remove this temp array
+      auto tempArray = jni::JArrayClass<jobject>::newArray(count);
+      for (size_t i = 0; i < convertedArgs.size(); i++) {
+        tempArray->setElement(i, convertedArgs[i].l);
+      }
+
+      auto Promise = rt.global().getPropertyAsFunction(rt, "Promise");
+      // Creates a JSI promise
+      jsi::Value promise = Promise.callAsConstructor(
+        rt,
+        createPromiseBody(rt, moduleRegistry, std::move(tempArray))
+      );
+      return promise;
+    }
+  );
+}
+
+jsi::Function MethodMetadata::createPromiseBody(
+  jsi::Runtime &runtime,
+  JSIInteropModuleRegistry *moduleRegistry,
+  jni::local_ref<jni::JArrayClass<jobject>::javaobject> &&args
+) {
+  return jsi::Function::createFromHostFunction(
+    runtime,
+    jsi::PropNameID::forAscii(runtime, "promiseFn"),
+    2,
+    [this, args = std::move(args), moduleRegistry](
+      jsi::Runtime &rt,
+      const jsi::Value &thisVal,
+      const jsi::Value *promiseConstructorArgs,
+      size_t promiseConstructorArgCount
+    ) {
+      if (promiseConstructorArgCount != 2) {
+        throw std::invalid_argument("Promise fn arg count must be 2");
+      }
+
+      jsi::Function resolveJSIFn = promiseConstructorArgs[0].getObject(rt).getFunction(rt);
+      jsi::Function rejectJSIFn = promiseConstructorArgs[1].getObject(rt).getFunction(rt);
+
+      auto &runtimeHolder = moduleRegistry->runtimeHolder;
+      jobject resolve = createJavaCallbackFromJSIFunction(
+        std::move(resolveJSIFn),
+        rt,
+        runtimeHolder->jsInvoker
+      ).release();
+
+      jobject reject = createJavaCallbackFromJSIFunction(
+        std::move(rejectJSIFn),
+        rt,
+        runtimeHolder->jsInvoker
+      ).release();
+
+      JNIEnv *env = jni::Environment::current();
+
+      auto &jPromise = CachedReferencesRegistry::instance()->getJClass(
+        "com/facebook/react/bridge/PromiseImpl");
+      jmethodID jPromiseConstructor = jPromise.getMethod(
+        "<init>",
+        "(Lcom/facebook/react/bridge/Callback;Lcom/facebook/react/bridge/Callback;)V"
+      );
+
+      // Creates a promise object
+      jobject promise = env->NewObject(
+        jPromise.clazz,
+        jPromiseConstructor,
+        resolve,
+        reject
+      );
+
+      // Cast in this place is safe, cause we know that this function expects promise.
+      auto asyncFunction = jni::static_ref_cast<JNIAsyncFunctionBody>(this->jBodyReference);
+      asyncFunction->invoke(
+        args,
+        promise
+      );
+
+      // We have to remove the local reference to the promise object.
+      // It doesn't mean that the promise will be deallocated, but rather that we move
+      // the ownership to the `JNIAsyncFunctionBody`.
+      env->DeleteLocalRef(promise);
+
+      return jsi::Value::undefined();
+    }
+  );
+}
+
+} // namespace expo

package/android/src/main/cpp/MethodMetadata.h

@@ -0,0 +1,131 @@
+// Copyright © 2021-present 650 Industries, Inc. (aka Expo)
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <fbjni/fbjni.h>
+#include <ReactCommon/TurboModuleUtils.h>
+#include <react/jni/ReadableNativeArray.h>
+#include <memory>
+#include <folly/dynamic.h>
+#include <jsi/JSIDynamic.h>
+
+namespace jni = facebook::jni;
+namespace jsi = facebook::jsi;
+namespace react = facebook::react;
+
+namespace expo {
+class JSIInteropModuleRegistry;
+
+/**
+ * A cpp version of the `expo.modules.kotlin.jni.CppType` enum.
+ * Used to determine which representation of the js value should be sent to the Kotlin.
+ */
+enum CppType {
+  DOUBLE = 1 << 0,
+  BOOLEAN = 1 << 1,
+  STRING = 1 << 2,
+  JS_OBJECT = 1 << 3,
+  JS_VALUE = 1 << 4,
+  READABLE_ARRAY = 1 << 5,
+  READABLE_MAP = 1 << 6
+};
+
+/**
+ * A class that holds information about the exported function.
+ */
+class MethodMetadata {
+public:
+  /**
+   * Function name
+   */
+  std::string name;
+  /**
+   * Number of arguments
+   */
+  int args;
+  /*
+   * Whether this function is async
+   */
+  bool isAsync;
+
+  std::unique_ptr<int[]> desiredTypes;
+
+  MethodMetadata(
+    std::string name,
+    int args,
+    bool isAsync,
+    std::unique_ptr<int[]> desiredTypes,
+    jni::global_ref<jobject> &&jBodyReference
+  );
+
+  // We deleted the copy contractor to not deal with transforming the ownership of the `jBodyReference`.
+  MethodMetadata(const MethodMetadata &) = delete;
+
+  MethodMetadata(MethodMetadata &&other) = default;
+
+  /**
+   * MethodMetadata owns the only reference to the Kotlin function.
+   * We have to clean that, cause it's a `global_ref`.
+   */
+  ~MethodMetadata() {
+    if (jBodyReference != nullptr) {
+      jBodyReference.release();
+    }
+  }
+
+  /**
+   * Transforms metadata to a jsi::Function.
+   *
+   * @param runtime
+   * @param moduleRegistry
+   * @return shared ptr to the jsi::Function that wrapped the underlying Kotlin's function.
+   */
+  std::shared_ptr<jsi::Function> toJSFunction(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *moduleRegistry
+  );
+
+  /**
+   * Calls the underlying Kotlin function.
+   */
+  jsi::Value callSync(
+    jsi::Runtime &rt,
+    JSIInteropModuleRegistry *moduleRegistry,
+    const jsi::Value *args,
+    size_t count
+  );
+
+private:
+  /**
+   * Reference to one of two java objects - `JNIFunctionBody` or `JNIAsyncFunctionBody`.
+   *
+   * In case when `isAsync` is `true`, this variable will point to `JNIAsyncFunctionBody`.
+   * Otherwise to `JNIFunctionBody`
+   */
+  jni::global_ref<jobject> jBodyReference;
+
+  /**
+   * To not create a jsi::Function always when we need it, we cached that value.
+   */
+  std::shared_ptr<jsi::Function> body = nullptr;
+
+  jsi::Function toSyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
+
+  jsi::Function toAsyncFunction(jsi::Runtime &runtime, JSIInteropModuleRegistry *moduleRegistry);
+
+  jsi::Function createPromiseBody(
+    jsi::Runtime &runtime,
+    JSIInteropModuleRegistry *moduleRegistry,
+    jni::local_ref<jni::JArrayClass<jobject>::javaobject> &&args
+  );
+
+  std::vector<jvalue> convertJSIArgsToJNI(
+    JSIInteropModuleRegistry *moduleRegistry,
+    JNIEnv *env,
+    jsi::Runtime &rt,
+    const jsi::Value *args,
+    size_t count
+  );
+};
+} // namespace expo

package/android/src/main/java/expo/modules/adapters/react/NativeModulesProxy.java

@@ -92,6 +92,8 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
   @Override
   public Map<String, Object> getConstants() {
     mModuleRegistry.ensureIsInitialized();
+    getKotlinInteropModuleRegistry().installJSIInterop();
+
     Collection<ExportedModule> exportedModules = mModuleRegistry.getAllExportedModules();
     Collection<ViewManager> viewManagers = mModuleRegistry.getAllViewManagers();
 

package/android/src/main/java/expo/modules/core/errors/ContextDestroyedException.kt

@@ -0,0 +1,7 @@
+package expo.modules.core.errors
+
+import kotlinx.coroutines.CancellationException
+
+private const val DEFAULT_MESSAGE = "App context destroyed. All coroutines are cancelled."
+
+class ContextDestroyedException(message: String = DEFAULT_MESSAGE) : CancellationException(message)

package/android/src/main/java/expo/modules/interfaces/permissions/Permissions.java

@@ -1,5 +1,7 @@
 package expo.modules.interfaces.permissions;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import expo.modules.core.Promise;
 
 public interface Permissions {
@@ -12,6 +14,20 @@ public interface Permissions {
     permissionsManager.getPermissionsWithPromise(promise, permissions);
   }
 
+  /**
+   * Compatibility method that accepts expo.modules.kotlin.Promise, but forward the logic to the other method
+   */
+  static void getPermissionsWithPermissionsManager(
+    @Nullable Permissions permissionsManager,
+    @NonNull final expo.modules.kotlin.Promise promise,
+    @NonNull String... permissions
+  ) {
+    getPermissionsWithPermissionsManager(permissionsManager, new Promise() {
+      @Override public void resolve(Object value) { promise.resolve(value); }
+      @Override public void reject(String c, String m, Throwable e) { promise.reject(c, m, e); }
+    }, permissions);
+  }
+
   static void askForPermissionsWithPermissionsManager(Permissions permissionsManager, final Promise promise, String... permissions) {
     if (permissionsManager == null) {
       promise.reject("E_NO_PERMISSIONS", "Permissions module is null. Are you sure all the installed Expo modules are properly linked?");
@@ -20,6 +36,20 @@ public interface Permissions {
     permissionsManager.askForPermissionsWithPromise(promise, permissions);
   }
 
+  /**
+   * Compatibility method that accepts expo.modules.kotlin.Promise, but forward the logic to the other method
+   */
+  static void askForPermissionsWithPermissionsManager(
+    @Nullable Permissions permissionsManager,
+    @NonNull final expo.modules.kotlin.Promise promise,
+    @NonNull String... permissions
+  ) {
+    askForPermissionsWithPermissionsManager(permissionsManager, new Promise() {
+      @Override public void resolve(Object value) { promise.resolve(value); }
+      @Override public void reject(String c, String m, Throwable e) { promise.reject(c, m, e); }
+    }, permissions);
+  }
+
   void getPermissionsWithPromise(final Promise promise, String... permissions);
 
   void getPermissions(final PermissionsResponseListener response, String... permissions);

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

@@ -1,9 +1,15 @@
+@file:OptIn(DelicateCoroutinesApi::class)
+
 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
+import expo.modules.core.errors.ContextDestroyedException
 import expo.modules.core.interfaces.ActivityProvider
 import expo.modules.interfaces.barcodescanner.BarCodeScannerInterface
 import expo.modules.interfaces.camera.CameraViewInterface
@@ -14,35 +20,86 @@ 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
 import expo.modules.kotlin.events.KEventEmitterWrapper
 import expo.modules.kotlin.events.KModuleEventEmitterWrapper
 import expo.modules.kotlin.events.OnActivityResultPayload
+import expo.modules.kotlin.jni.JSIInteropModuleRegistry
 import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.providers.CurrentActivityProvider
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+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, 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()
+      ?.takeIf { it != 0L }
+      ?.let {
+        jsiInterop.installJSI(
+          it,
+          reactContext.catalystInstance.jsCallInvokerHolder as CallInvokerHolderImpl,
+          reactContext.catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
+        )
+      }
+  }
+
   /**
    * Returns a legacy module implementing given interface.
    */
@@ -149,9 +206,15 @@ class AppContext(
     reactContextHolder.get()?.removeLifecycleEventListener(reactLifecycleDelegate)
     registry.post(EventName.MODULE_DESTROY)
     registry.cleanUp()
+    modulesQueue.cancel(ContextDestroyedException())
   }
 
   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)
   }
 
@@ -160,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,
@@ -181,4 +250,30 @@ class AppContext(
       intent
     )
   }
+
+// region CurrentActivityProvider
+
+  override val currentActivity: AppCompatActivity?
+    get() {
+      val currentActivity = this.activityProvider?.currentActivity ?: return null
+
+      check(currentActivity is AppCompatActivity) {
+        "Current Activity is of incorrect class, expected AppCompatActivity, received ${currentActivity.localClassName}"
+      }
+
+      return currentActivity
+    }
+
+// endregion
+
+// region AppContextActivityResultCaller
+
+  @MainThread
+  override suspend fun <I : Serializable, O> registerForActivityResult(
+    contract: AppContextActivityResultContract<I, O>,
+    fallbackCallback: AppContextActivityResultFallbackCallback<I, O>
+  ): AppContextActivityResultLauncher<I, O> =
+    activityResultsManager.registerForActivityResult(contract, fallbackCallback)
+
+// endregion
 }