expo-modules-core 0.4.9 → 0.6.2

package/CHANGELOG.md

@@ -10,13 +10,44 @@
 
 ### 💡 Others
 
-## 0.4.9 — 2021-12-08
+## 0.6.2 — 2021-12-15
 
 ### 🎉 New features
 
+- Add `onNewIntent` and `onBackPressed` support to `ReactActivityLifecycleListener`. ([#15550](https://github.com/expo/expo/pull/15550) by [@Kudo](https://github.com/Kudo))
+
+## 0.6.1 — 2021-12-08
+
+_This version does not introduce any user-facing changes._
+
+## 0.6.0 — 2021-12-03
+
+### 🎉 New features
+
+- Made `Foundation.URL` a convertible type to consistently normalize file paths to file URLs. ([#15278](https://github.com/expo/expo/pull/15278) by [@tsapeta](https://github.com/tsapeta))
 - Improve external Android handlers or listeners backward compatibility by Java 8 interface default method. ([#15421](https://github.com/expo/expo/pull/15421) by [@kudo](https://github.com/kudo))
 
-## 0.4.8 — 2021-11-11
+### 💡 Others
+
+- Add parameter to `ReactNativeHostHandler.onDidCreateReactInstanceManager` on Android. ([#15221](https://github.com/expo/expo/pull/15221) by [@esamelson](https://github.com/esamelson))
+- Make the no-argument module initializer unavailable — `onCreate` definition component should be used instead. ([#15262](https://github.com/expo/expo/pull/15262) by [@tsapeta](https://github.com/tsapeta))
+
+## 0.5.0 — 2021-11-17
+
+### 🎉 New features
+
+- Method calls on iOS now can go through the JSI instead of the bridge (opt-in feature). ([#14626](https://github.com/expo/expo/pull/14626) by [@tsapeta](https://github.com/tsapeta))
+- `AppDelegateWrapper` is now written in Swift and is independent of the singleton modules. ([#14867](https://github.com/expo/expo/pull/14867) by [@tsapeta](https://github.com/tsapeta))
+- Implemented sending native events to JavaScript in Sweet API on iOS. ([#14958](https://github.com/expo/expo/pull/14958) by [@tsapeta](https://github.com/tsapeta))
+- [Sweet API] Introduced Convertibles on iOS — a way to use custom types as method arguments if they can be converted from JavaScript values. Provided implementation for some common CoreGraphics types. ([#14988](https://github.com/expo/expo/pull/14988) by [@tsapeta](https://github.com/tsapeta))
+- Introduce `ReactActivityHandler` and support `createReactRootView` hook. ([#14883](https://github.com/expo/expo/pull/14883) by [@kudo](https://github.com/kudo))
+- [Sweet API] Added support for array types in method arguments on iOS. ([#15042](https://github.com/expo/expo/pull/15042) by [@tsapeta](https://github.com/tsapeta))
+- [Sweet API] Added support for optional types in method arguments on iOS. ([#15068](https://github.com/expo/expo/pull/15068) by [@tsapeta](https://github.com/tsapeta))
+- [Sweet API] Added support for enums in method arguments on iOS. ([#15129](https://github.com/expo/expo/pull/15129) by [@tsapeta](https://github.com/tsapeta))
+- [Sweet API] Automatic conversion is now available for view props setters. ([#15132](https://github.com/expo/expo/pull/15132) by [@tsapeta](https://github.com/tsapeta))
+- [Sweet API] Added experimental implementation of the new API in Kotlin. (by [@lukmccall](https://github.com/lukmccall))
+- Introduce EXAppDefines to get app building configurations. ([#14428](https://github.com/expo/expo/pull/14428) by [@kudo](https://github.com/kudo))
+- Introduce React Native bridge delegate handlers on iOS. ([#15138](https://github.com/expo/expo/pull/15138) by [@kudo](https://github.com/kudo))
 
 ### 🐛 Bug fixes
 

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven'
 
 group = 'host.exp.exponent'
-version = '0.4.9'
+version = '0.6.2'
 
 buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
@@ -58,7 +58,7 @@ android {
     targetSdkVersion safeExtGet("targetSdkVersion", 30)
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "0.4.9"
+    versionName "0.6.2"
   }
   lintOptions {
     abortOnError false
@@ -66,10 +66,23 @@ android {
   kotlinOptions {
     jvmTarget = JavaVersion.VERSION_1_8
   }
+
+  testOptions {
+    unitTests.all {
+      testLogging {
+        outputs.upToDateWhen { false }
+        events "passed", "failed", "skipped", "standardError"
+        showCauses true
+        showExceptions true
+        showStandardStreams true
+      }
+    }
+  }
 }
 
 dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.4.21')}"
+  implementation "org.jetbrains.kotlin:kotlin-reflect:${safeExtGet('kotlinVersion', '1.4.21')}"
   implementation 'androidx.annotation:annotation:1.2.0'
 
   // used only in `expo.modules.core.errors.ModuleDestroyedException` for API export
@@ -77,4 +90,19 @@ dependencies {
 
   //noinspection GradleDynamicVersion
   implementation 'com.facebook.react:react-native:+'
+
+  testImplementation 'androidx.test:core:1.4.0'
+  testImplementation 'junit:junit:4.13.1'
+  testImplementation 'io.mockk:mockk:1.10.6'
+  testImplementation "com.google.truth:truth:1.1.2"
+}
+
+/**
+ * To make the users of annotations @OptIn and @RequiresOptIn aware of their experimental status,
+ * the compiler raises warnings when compiling the code with these annotations:
+ * This class can only be used with the compiler argument '-Xopt-in=kotlin.RequiresOptIn'
+ * To remove the warnings, we add the compiler argument -Xopt-in=kotlin.RequiresOptIn.
+ */
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
+  kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"
 }

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

@@ -5,14 +5,18 @@ import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
 import expo.modules.adapters.react.views.SimpleViewManagerAdapter;
 import expo.modules.adapters.react.views.ViewGroupManagerAdapter;
 import expo.modules.core.ModuleRegistry;
 import expo.modules.core.interfaces.InternalModule;
 import expo.modules.core.interfaces.Package;
-
-import java.util.ArrayList;
-import java.util.List;
+import expo.modules.kotlin.KotlinInteropModuleRegistry;
+import expo.modules.kotlin.ModulesProvider;
+import expo.modules.kotlin.views.ViewWrapperDelegateHolder;
 
 /**
  * An adapter over {@link ModuleRegistry}, compatible with React (implementing {@link ReactPackage}).
@@ -21,7 +25,11 @@ import java.util.List;
  */
 public class ModuleRegistryAdapter implements ReactPackage {
   protected ReactModuleRegistryProvider mModuleRegistryProvider;
+  protected ModulesProvider mModulesProvider;
   protected ReactAdapterPackage mReactAdapterPackage = new ReactAdapterPackage();
+  private NativeModulesProxy mModulesProxy;
+  // We need to save all view holders to update them when the new kotlin module registry will be created.
+  private List<ViewWrapperDelegateHolder> mWrapperDelegateHolders = null;
 
   public ModuleRegistryAdapter(List<Package> packageList) {
     mModuleRegistryProvider = new ReactModuleRegistryProvider(packageList, null);
@@ -31,6 +39,11 @@ public class ModuleRegistryAdapter implements ReactPackage {
     mModuleRegistryProvider = moduleRegistryProvider;
   }
 
+  public ModuleRegistryAdapter(ReactModuleRegistryProvider moduleRegistryProvider, ModulesProvider modulesProvider) {
+    mModuleRegistryProvider = moduleRegistryProvider;
+    mModulesProvider = modulesProvider;
+  }
+
   @Override
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
     ModuleRegistry moduleRegistry = mModuleRegistryProvider.get(reactContext);
@@ -39,13 +52,20 @@ public class ModuleRegistryAdapter implements ReactPackage {
       moduleRegistry.registerInternalModule(internalModule);
     }
 
-    return getNativeModulesFromModuleRegistry(reactContext, moduleRegistry);
+    List<NativeModule> nativeModules = getNativeModulesFromModuleRegistry(reactContext, moduleRegistry);
+    if (mWrapperDelegateHolders != null) {
+      KotlinInteropModuleRegistry kotlinInteropModuleRegistry = mModulesProxy.getKotlinInteropModuleRegistry();
+      kotlinInteropModuleRegistry.updateModuleHoldersInViewManagers(mWrapperDelegateHolders);
+    }
+
+    return nativeModules;
   }
 
   protected List<NativeModule> getNativeModulesFromModuleRegistry(ReactApplicationContext reactContext, ModuleRegistry moduleRegistry) {
     List<NativeModule> nativeModulesList = new ArrayList<>(2);
 
-    nativeModulesList.add(new NativeModulesProxy(reactContext, moduleRegistry));
+    mModulesProxy = createNativeModulesProxy(reactContext, moduleRegistry);
+    nativeModulesList.add(mModulesProxy);
 
     // Add listener that will notify expo.modules.core.ModuleRegistry when all modules are ready
     nativeModulesList.add(new ModuleRegistryReadyNotifier(moduleRegistry));
@@ -73,6 +93,23 @@ public class ModuleRegistryAdapter implements ReactPackage {
           break;
       }
     }
+
+    // We assume that `createNativeModules` was called first.
+    NativeModulesProxy modulesProxy = Objects.requireNonNull(mModulesProxy);
+    KotlinInteropModuleRegistry kotlinInteropModuleRegistry = modulesProxy.getKotlinInteropModuleRegistry();
+    List<ViewManager<?, ?>> kViewManager = kotlinInteropModuleRegistry.exportViewManagers();
+    // Saves all holders that needs to be in sync with module registry
+    mWrapperDelegateHolders = kotlinInteropModuleRegistry.extractViewManagersDelegateHolders(kViewManager);
+    viewManagerList.addAll(kViewManager);
+
     return viewManagerList;
   }
+
+  private NativeModulesProxy createNativeModulesProxy(ReactApplicationContext reactContext, ModuleRegistry moduleRegistry) {
+    if (mModulesProvider != null) {
+      return new NativeModulesProxy(reactContext, moduleRegistry, mModulesProvider);
+    } else {
+      return new NativeModulesProxy(reactContext, moduleRegistry);
+    }
+  }
 }

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

@@ -14,13 +14,19 @@ import expo.modules.core.ExportedModule;
 import expo.modules.core.ModuleRegistry;
 import expo.modules.core.ViewManager;
 import expo.modules.core.interfaces.ExpoMethod;
+import expo.modules.kotlin.ExpoModulesHelper;
+import expo.modules.kotlin.KotlinInteropModuleRegistry;
+import expo.modules.kotlin.KPromiseWrapper;
+import expo.modules.kotlin.ModulesProvider;
 
+import java.lang.ref.WeakReference;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 
 import javax.annotation.Nullable;
 
@@ -45,12 +51,36 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
   private ModuleRegistry mModuleRegistry;
   private Map<String, Map<String, Integer>> mExportedMethodsKeys;
   private Map<String, SparseArray<String>> mExportedMethodsReverseKeys;
+  private KotlinInteropModuleRegistry mKotlinInteropModuleRegistry;
 
   public NativeModulesProxy(ReactApplicationContext context, ModuleRegistry moduleRegistry) {
     super(context);
     mModuleRegistry = moduleRegistry;
     mExportedMethodsKeys = new HashMap<>();
     mExportedMethodsReverseKeys = new HashMap<>();
+
+    mKotlinInteropModuleRegistry = new KotlinInteropModuleRegistry(
+      Objects.requireNonNull(ExpoModulesHelper.Companion.getModulesProvider()),
+      moduleRegistry,
+      new WeakReference<>(context)
+    );
+  }
+
+  public NativeModulesProxy(ReactApplicationContext context, ModuleRegistry moduleRegistry, ModulesProvider modulesProvider) {
+    super(context);
+    mModuleRegistry = moduleRegistry;
+    mExportedMethodsKeys = new HashMap<>();
+    mExportedMethodsReverseKeys = new HashMap<>();
+
+    mKotlinInteropModuleRegistry = new KotlinInteropModuleRegistry(
+      Objects.requireNonNull(modulesProvider),
+      moduleRegistry,
+      new WeakReference<>(context)
+    );
+  }
+
+  public KotlinInteropModuleRegistry getKotlinInteropModuleRegistry() {
+    return mKotlinInteropModuleRegistry;
   }
 
   @Override
@@ -79,11 +109,19 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
       exportedMethodsMap.put(moduleName, exportedMethods);
     }
 
+    modulesConstants.putAll(mKotlinInteropModuleRegistry.exportedModulesConstants());
+    exportedMethodsMap.putAll(mKotlinInteropModuleRegistry.exportMethods((name, info) -> {
+      assignExportedMethodsKeys(name, (List<Map<String, Object>>) info);
+      return null;
+    }));
+
     for (ViewManager viewManager : viewManagers) {
       viewManagersNames.add(viewManager.getName());
     }
 
-    Map<String, Object> constants = new HashMap<>(2);
+    viewManagersNames.addAll(mKotlinInteropModuleRegistry.exportedViewManagersNames());
+
+    Map<String, Object> constants = new HashMap<>(3);
     constants.put(MODULES_CONSTANTS_KEY, modulesConstants);
     constants.put(EXPORTED_METHODS_KEY, exportedMethodsMap);
     constants.put(VIEW_MANAGERS_NAMES_KEY, viewManagersNames);
@@ -110,6 +148,11 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
       return;
     }
 
+    if (mKotlinInteropModuleRegistry.hasModule(moduleName)) {
+      mKotlinInteropModuleRegistry.callMethod(moduleName, methodName, arguments, new KPromiseWrapper(promise));
+      return;
+    }
+
     try {
       List<Object> nativeArguments = getNativeArgumentsForMethod(arguments, mModuleRegistry.getExportedModule(moduleName).getExportedMethodInfos().get(methodName));
       nativeArguments.add(new PromiseWrapper(promise));
@@ -121,9 +164,9 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
       promise.reject(UNEXPECTED_ERROR, "Encountered an exception while calling native method: " + e.getMessage(), e);
     } catch (NoSuchMethodException e) {
       promise.reject(
-          UNDEFINED_METHOD_ERROR,
-          "Method " + methodName + " of Java module " + moduleName + " is undefined.",
-          e
+        UNDEFINED_METHOD_ERROR,
+        "Method " + methodName + " of Java module " + moduleName + " is undefined.",
+        e
       );
     }
   }
@@ -157,7 +200,7 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
    * Returns methodInfo Map (a Map containing a value for key argumentsCount).
    */
   private Map<String, Object> getMethodInfo(String name, Method method) {
-    Map<String, Object> info = new HashMap<>(1);
+    Map<String, Object> info = new HashMap<>(2);
     info.put(METHOD_INFO_NAME, name);
     info.put(METHOD_INFO_ARGUMENTS_COUNT, method.getParameterTypes().length - 1); // - 1 is for the Promise
     return info;
@@ -200,5 +243,6 @@ public class NativeModulesProxy extends ReactContextBaseJavaModule {
   @Override
   public void onCatalystInstanceDestroy() {
     mModuleRegistry.onDestroy();
+    mKotlinInteropModuleRegistry.onDestroy();
   }
 }

package/android/src/main/java/expo/modules/core/BasePackage.java

@@ -5,6 +5,7 @@ import android.content.Context;
 import expo.modules.core.interfaces.ApplicationLifecycleListener;
 import expo.modules.core.interfaces.InternalModule;
 import expo.modules.core.interfaces.Package;
+import expo.modules.core.interfaces.ReactActivityHandler;
 import expo.modules.core.interfaces.ReactActivityLifecycleListener;
 import expo.modules.core.interfaces.ReactNativeHostHandler;
 import expo.modules.core.interfaces.SingletonModule;
@@ -49,4 +50,9 @@ public class BasePackage implements Package {
   public List<ReactActivityLifecycleListener> createReactActivityLifecycleListeners(Context activityContext) {
     return Collections.emptyList();
   }
+
+  @Override
+  public List<ReactActivityHandler> createReactActivityHandlers(Context activityContext) {
+    return Collections.emptyList();
+  }
 }

package/android/src/main/java/expo/modules/core/ModulePriorities.kt

@@ -0,0 +1,25 @@
+package expo.modules.core
+
+/**
+ * This class determines the order of the following handlers/listeners
+ * - {@link ReactNativeHostHandler}
+ * - {@link ApplicationLifecycleListener}
+ * - {@link ReactActivityLifecycleListener}
+ * - {@link ReactActivityHandler}
+ *
+ * The priority is only for internal use and we maintain a pre-defined {@link SUPPORTED_MODULES} map.
+ */
+object ModulePriorities {
+  fun get(packageName: String?): Int {
+    return packageName?.let {
+      return SUPPORTED_MODULES[it] ?: 0
+    } ?: 0
+  }
+
+  private val SUPPORTED_MODULES = mapOf(
+    // {key} to {value}
+    // key: full qualified class name
+    // value: priority value, the higher value takes precedence
+    "expo.modules.updates.UpdatesPackage" to 10,
+  )
+}

package/android/src/main/java/expo/modules/core/interfaces/ActivityEventListener.java

@@ -3,8 +3,10 @@ package expo.modules.core.interfaces;
 import android.app.Activity;
 import android.content.Intent;
 
+import androidx.annotation.Nullable;
+
 public interface ActivityEventListener {
-  public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data);
+  public void onActivityResult(Activity activity, int requestCode, int resultCode, @Nullable Intent data);
 
   // Called when a new intent is passed to the activity
   public void onNewIntent(Intent intent);

package/android/src/main/java/expo/modules/core/interfaces/Package.java

@@ -43,4 +43,8 @@ public interface Package {
   default List<? extends ReactActivityLifecycleListener> createReactActivityLifecycleListeners(Context activityContext) {
     return Collections.emptyList();
   }
+
+  default List<? extends ReactActivityHandler> createReactActivityHandlers(Context activityContext) {
+    return Collections.emptyList();
+  }
 }

package/android/src/main/java/expo/modules/core/interfaces/ReactActivityHandler.java

@@ -0,0 +1,21 @@
+package expo.modules.core.interfaces;
+
+import android.app.Activity;
+import com.facebook.react.ReactRootView;
+
+import androidx.annotation.Nullable;
+
+/**
+ * A handler API for modules to override default ReactActivity behaviors.
+ * Used by {@link ReactActivityDelegateWrapper}
+ */
+public interface ReactActivityHandler {
+  /**
+   * Given modules a chance to override the default {@link ReactRootView}
+   * @return the override ReactRootView instance or null if not to override
+   */
+  @Nullable
+  default ReactRootView createReactRootView(Activity activity) {
+    return null;
+  }
+}

package/android/src/main/java/expo/modules/core/interfaces/ReactActivityLifecycleListener.java

@@ -1,6 +1,7 @@
 package expo.modules.core.interfaces;
 
 import android.app.Activity;
+import android.content.Intent;
 import android.os.Bundle;
 
 public interface ReactActivityLifecycleListener {
@@ -11,4 +12,26 @@ public interface ReactActivityLifecycleListener {
   default void onPause(Activity activity) {}
 
   default void onDestroy(Activity activity) {}
+
+  /**
+   * Called when {@link com.facebook.react.ReactActivity} received `onNewIntent`
+   * Every listener will receive this callback.
+   * `ReactActivityDelegateWrapper.onNewIntent` will get `true` if there's some module returns `true`
+   *
+   * @return true if this module wants to return `true` from `ReactActivityDelegateWrapper.onNewIntent`
+   */
+  default boolean onNewIntent(Intent intent) {
+    return false;
+  }
+
+  /**
+   * Called when {@link com.facebook.react.ReactActivity} received `onBackPressed`
+   * Every listener will receive this callback.
+   * `ReactActivityDelegateWrapper.onBackPressed` will get `true` if there's some module returns `true`
+   *
+   * @return true if this module wants to return `true` from `ReactActivityDelegateWrapper.onBackPressed`
+   */
+  default boolean onBackPressed() {
+    return false;
+  }
 }

package/android/src/main/java/expo/modules/core/interfaces/ReactNativeHostHandler.java

@@ -42,6 +42,8 @@ public interface ReactNativeHostHandler {
     return null;
   }
 
+  //region event listeners
+
   /**
    * Given chance for JSI modules to register, e.g. for react-native-reanimated
    *
@@ -53,4 +55,16 @@ public interface ReactNativeHostHandler {
     boolean useDeveloperSupport
   ) {
   }
+
+  /**
+   * Callback before {@link ReactInstanceManager} creation
+   */
+  default void onWillCreateReactInstanceManager(boolean useDeveloperSupport) {}
+
+  /**
+   * Callback after {@link ReactInstanceManager} creation
+   */
+  default void onDidCreateReactInstanceManager(ReactInstanceManager reactInstanceManager, boolean useDeveloperSupport) {}
+
+  //endregion
 }

package/android/src/main/java/expo/modules/core/utilities/KotlinUtilities.kt

@@ -0,0 +1,23 @@
+package expo.modules.core.utilities
+
+/**
+ * Returns receiver, or block result if the receiver is `null`
+ *
+ * A more semantic equivalent to: `nullable ?: run { ... }`:
+ * ```
+ * val nonNullable1 = sthNullable.ifNull { ... }
+ * val nonNullable2 = sthNullable ?: run { ... }
+ * ```
+ */
+inline fun <T> T?.ifNull(block: () -> T): T = this ?: block()
+
+/**
+ * If the receiver is instance of `T`, returns the receiver, otherwise returns `null`
+ *
+ * Works the same as the `as?` operator, but allows method chaining without parentheses:
+ * ```
+ *   val x = a.b.takeIfInstanceOf<Number>?.someMethod()
+ *   val y = (a.b as? Number)?.someMethod() // same, but needs parenthesis
+ * ```
+ */
+inline fun <reified T> Any?.takeIfInstanceOf(): T? = if (this is T) this else null

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

@@ -0,0 +1,166 @@
+package expo.modules.kotlin
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import com.facebook.react.bridge.ReactApplicationContext
+import expo.modules.core.interfaces.ActivityProvider
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.interfaces.barcodescanner.BarCodeScannerInterface
+import expo.modules.interfaces.camera.CameraViewInterface
+import expo.modules.interfaces.constants.ConstantsInterface
+import expo.modules.interfaces.filesystem.FilePermissionModuleInterface
+import expo.modules.interfaces.font.FontManagerInterface
+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.events.EventName
+import expo.modules.kotlin.events.KEventEmitterWrapper
+import expo.modules.kotlin.events.OnActivityResultPayload
+import expo.modules.kotlin.modules.Module
+import java.lang.ref.WeakReference
+
+class AppContext(
+  modulesProvider: ModulesProvider,
+  val legacyModuleRegistry: expo.modules.core.ModuleRegistry,
+  private val reactContextHolder: WeakReference<ReactApplicationContext>
+) {
+  val registry = ModuleRegistry(WeakReference(this)).register(modulesProvider)
+  private val reactLifecycleDelegate = ReactLifecycleDelegate(this)
+
+  init {
+    requireNotNull(reactContextHolder.get()) {
+      "The app context should be created with valid react context."
+    }.apply {
+      addLifecycleEventListener(reactLifecycleDelegate)
+      addActivityEventListener(reactLifecycleDelegate)
+    }
+  }
+
+  /**
+   * Returns a legacy module implementing given interface.
+   */
+  inline fun <reified Module> legacyModule(): Module? {
+    return try {
+      legacyModuleRegistry.getModule(Module::class.java)
+    } catch (_: Exception) {
+      null
+    }
+  }
+
+  /**
+   * Provides access to app's constants from the legacy module registry.
+   */
+  val constants: ConstantsInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the file system manager from the legacy module registry.
+   */
+  val filePermission: FilePermissionModuleInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the permissions manager from the legacy module registry
+   */
+  val permissions: Permissions?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the image loader from the legacy module registry
+   */
+  val imageLoader: ImageLoaderInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the bar code scanner manager from the legacy module registry
+   */
+  val barcodeScanner: BarCodeScannerInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the camera view manager from the legacy module registry
+   */
+  val camera: CameraViewInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the font manager from the legacy module registry
+   */
+  val font: FontManagerInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the sensor manager from the legacy module registry
+   */
+  val sensor: SensorServiceInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the task manager from the legacy module registry
+   */
+  val taskManager: TaskManagerInterface?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the activity provider from the legacy module registry
+   */
+  val activityProvider: ActivityProvider?
+    get() = legacyModule()
+
+  /**
+   * Provides access to the react application context
+   */
+  val reactContext: Context?
+    get() = reactContextHolder.get()
+
+  /**
+   * Provides access to the event emitter
+   */
+  fun eventEmitter(module: Module): EventEmitter? {
+    val legacyEventEmitter = legacyModule<EventEmitter>() ?: return null
+    return KEventEmitterWrapper(
+      requireNotNull(registry.getModuleHolder(module)) {
+        "Cannot create an event emitter for the module that isn't present in the module registry."
+      },
+      legacyEventEmitter
+    )
+  }
+
+  fun onDestroy() {
+    reactContextHolder.get()?.removeLifecycleEventListener(reactLifecycleDelegate)
+    registry.post(EventName.MODULE_DESTROY)
+  }
+
+  fun onHostResume() {
+    registry.post(EventName.ACTIVITY_ENTERS_FOREGROUND)
+  }
+
+  fun onHostPause() {
+    registry.post(EventName.ACTIVITY_ENTERS_BACKGROUND)
+  }
+
+  fun onHostDestroy() {
+    registry.post(EventName.ACTIVITY_DESTROYS)
+  }
+
+  fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    registry.post(
+      EventName.ON_ACTIVITY_RESULT,
+      activity,
+      OnActivityResultPayload(
+        requestCode,
+        resultCode,
+        data
+      )
+    )
+  }
+
+  fun onNewIntent(intent: Intent?) {
+    registry.post(
+      EventName.ON_NEW_INTENT,
+      intent
+    )
+  }
+}

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

@@ -0,0 +1,9 @@
+package expo.modules.kotlin
+
+import com.facebook.react.bridge.Dynamic
+
+inline fun <T> Dynamic.recycle(block: Dynamic.() -> T): T {
+  val result = block(this)
+  this.recycle()
+  return result
+}