expo-modules-core 1.10.0 → 1.11.0

package/CHANGELOG.md

@@ -10,6 +10,28 @@
 
 ### 💡 Others
 
+## 1.11.0 — 2023-12-12
+
+### 🎉 New features
+
+- Added support for React Native 0.73.0. ([#24971](https://github.com/expo/expo/pull/24971), [#25453](https://github.com/expo/expo/pull/25453) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+- Added `Data <-> Uint8Array` convertible on iOS. ([#25726](https://github.com/expo/expo/pull/25726) by [@kudo](https://github.com/kudo))
+- Added `ByteArray <-> Uint8Array` convertible on Android. ([#25727](https://github.com/expo/expo/pull/25727) by [@kudo](https://github.com/kudo))
+
+### 🐛 Bug fixes
+
+- [Android] Prevent the app from crashing during reloading when an unfinished promise tries to execute.
+- [Android] Fix `JavaScriptFunction` not working when the return type wasn't provided. ([#25688](https://github.com/expo/expo/pull/25688) by [@lukmccall](https://github.com/lukmccall))
+- [Android] Fix requesting only `WRITE_SETTINGS` rejecting promise even if the permission was granted. ([#25732](https://github.com/expo/expo/pull/25732) by [@lukmccall](https://github.com/lukmccall))
+- [Android] Fix functions that are scheduled on the main thread weren't being called as soon as possible. ([#25757](https://github.com/expo/expo/pull/25757) by [@lukmccall](https://github.com/lukmccall))
+
+### 💡 Others
+
+- [iOS] Made dynamic types creation faster. ([#25390](https://github.com/expo/expo/pull/25390) by [@tsapeta](https://github.com/tsapeta))
+- [iOS] Add `FileSystemUtilities` to replace legacy interfaces. ([#25495](https://github.com/expo/expo/pull/25495) by [@alanhughes](https://github.com/alanjhughes))
+- Bump C++ compiler setting to C++20. ([#25548](https://github.com/expo/expo/pull/25548) by [@kudo](https://github.com/kudo))
+- Marked `NativeModulesProxy` as deprecated in favor of `requireNativeModule` and `requireOptionalNativeModule`. ([#25666](https://github.com/expo/expo/pull/25666) by [@tsapeta](https://github.com/tsapeta))
+
 ## 1.10.0 — 2023-11-14
 
 ### 🛠 Breaking changes

package/ExpoModulesCore.podspec

@@ -13,8 +13,8 @@ reactNativeMinorVersion = reactNativeVersion.split('.')[1].to_i
 
 fabric_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 fabric_compiler_flags = '-DRN_FABRIC_ENABLED -DRCT_NEW_ARCH_ENABLED'
-folly_version = '2021.07.22.00'
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+folly_version = '2022.05.16.00'
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_CFG_NO_COROUTINES=1 -Wno-comma -Wno-shorten-64-to-32'
 
 Pod::Spec.new do |s|
   s.name           = 'ExpoModulesCore'
@@ -46,7 +46,7 @@ Pod::Spec.new do |s|
   s.pod_target_xcconfig = {
     'USE_HEADERMAP' => 'YES',
     'DEFINES_MODULE' => 'YES',
-    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20',
     'SWIFT_COMPILATION_MODE' => 'wholemodule',
     'HEADER_SEARCH_PATHS' => header_search_paths.join(' '),
     "FRAMEWORK_SEARCH_PATHS" => "\"${PODS_CONFIGURATION_BUILD_DIR}/React-hermes\"",
@@ -56,6 +56,7 @@ Pod::Spec.new do |s|
     '"${PODS_CONFIGURATION_BUILD_DIR}/ExpoModulesCore/Swift Compatibility Header"',
     '"$(PODS_ROOT)/Headers/Private/React-bridging/react/bridging"',
     '"$(PODS_CONFIGURATION_BUILD_DIR)/React-bridging/react_bridging.framework/Headers"',
+    '"$(PODS_ROOT)/Headers/Private/Yoga"',
   ]
   if fabric_enabled && ENV['USE_FRAMEWORKS']
     user_header_search_paths << "\"$(PODS_ROOT)/DoubleConversion\""

package/android/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.4.1)
 project(expo-modules-core)
 
 set(CMAKE_VERBOSE_MAKEFILE ON)
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(PACKAGE_NAME "expo-modules-core")
 set(BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
 

package/android/build.gradle

@@ -5,7 +5,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '1.10.0'
+version = '1.11.0'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 if (expoModulesCorePlugin.exists()) {
@@ -143,7 +143,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "1.10.0"
+    versionName "1.11.0"
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled.toString()
 
     testInstrumentationRunner "expo.modules.TestRunner"

package/android/proguard-rules.pro

@@ -1,4 +1,3 @@
-
 -keepclassmembers class * {
   @expo.modules.core.interfaces.ExpoProp *;
 }
@@ -16,7 +15,12 @@
   *;
 }
 -keepclassmembers enum * implements expo.modules.kotlin.types.Enumerable {
-  *; 
+  *;
+}
+
+-keep,allowoptimization,allowobfuscation class * extends expo.modules.kotlin.modules.Module {
+  public <init>();
+  public expo.modules.kotlin.modules.ModuleDefinitionData definition();
 }
 
 -keepclassmembers class * implements expo.modules.kotlin.views.ExpoView {

package/android/src/fabric/CMakeLists.txt

@@ -12,7 +12,7 @@ add_library(fabric STATIC
 include("${REACT_NATIVE_DIR}/ReactAndroid/cmake-utils/folly-flags.cmake")
 
 target_compile_options(fabric PRIVATE
-  "-std=c++17"
+  "-std=c++20"
   ${folly_FLAGS}
 )
 
@@ -43,6 +43,7 @@ target_link_libraries(fabric
   ReactAndroid::react_render_debug
   ReactAndroid::react_render_graphics
   ReactAndroid::react_render_mapbuffer
+  ReactAndroid::react_utils
   ReactAndroid::rrc_view
   ReactAndroid::runtimeexecutor
   ReactAndroid::yoga

package/android/src/main/cpp/JSIInteropModuleRegistry.cpp

@@ -30,6 +30,7 @@ void JSIInteropModuleRegistry::registerNatives() {
                    makeNativeMethod("global", JSIInteropModuleRegistry::global),
                    makeNativeMethod("createObject", JSIInteropModuleRegistry::createObject),
                    makeNativeMethod("drainJSEventLoop", JSIInteropModuleRegistry::drainJSEventLoop),
+                   makeNativeMethod("wasDeallocated", JSIInteropModuleRegistry::jniWasDeallocated),
                  });
 }
 
@@ -188,4 +189,8 @@ void JSIInteropModuleRegistry::registerSharedObject(
     );
   method(javaPart_, std::move(native), std::move(js));
 }
+
+void JSIInteropModuleRegistry::jniWasDeallocated() {
+  wasDeallocated = true;
+}
 } // namespace expo

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

@@ -109,6 +109,8 @@ public:
   std::shared_ptr<JavaScriptRuntime> runtimeHolder;
   std::unique_ptr<JSReferencesCache> jsRegistry;
   jni::global_ref<JNIDeallocator::javaobject> jniDeallocator;
+
+  bool wasDeallocated = false;
 private:
   friend HybridBase;
   jni::global_ref<JSIInteropModuleRegistry::javaobject> javaPart_;
@@ -123,5 +125,7 @@ private:
   inline jni::local_ref<JavaScriptModuleObject::javaobject> callGetCoreModuleObject() const;
 
   inline bool callHasModule(const std::string &moduleName) const;
+
+  void jniWasDeallocated();
 };
 } // namespace expo

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

@@ -71,6 +71,10 @@ jni::local_ref<JavaCallback::JavaPart> createJavaCallbackFromJSIFunction(
           }
 
           jsi::Value arg = jsi::valueFromDynamic(strongWrapper2->runtime(), responses);
+          auto enhancedArg = decorateValueForDynamicExtension(strongWrapper2->runtime(), arg);
+          if (enhancedArg) {
+            arg = std::move(*enhancedArg);
+          }
           if (!isRejectCallback) {
             strongWrapper2->callback().call(
               strongWrapper2->runtime(),
@@ -308,6 +312,15 @@ jsi::Function MethodMetadata::toAsyncFunction(
       const jsi::Value *args,
       size_t count
     ) -> jsi::Value {
+      /**
+       * Halt execution during cleaning phase as modules and js context will be deallocated soon.
+       * The output of this method doesn't matter.
+       * We added that check to prevent the app from crashing when users reload their apps.
+       */
+      if (moduleRegistry->wasDeallocated) {
+        return jsi::Value::undefined();
+      }
+
       JNIEnv *env = jni::Environment::current();
 
       /**

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

@@ -19,13 +19,14 @@ enum CppType {
   JS_VALUE = 1 << 7,
   READABLE_ARRAY = 1 << 8,
   READABLE_MAP = 1 << 9,
-  TYPED_ARRAY = 1 << 10,
-  PRIMITIVE_ARRAY = 1 << 11,
-  LIST = 1 << 12,
-  MAP = 1 << 13,
-  VIEW_TAG = 1 << 14,
-  SHARED_OBJECT_ID = 1 << 15,
-  JS_FUNCTION = 1 << 16,
-  ANY = 1 << 17
+  UINT8_TYPED_ARRAY = 1 << 10,
+  TYPED_ARRAY = 1 << 11,
+  PRIMITIVE_ARRAY = 1 << 12,
+  LIST = 1 << 13,
+  MAP = 1 << 14,
+  VIEW_TAG = 1 << 15,
+  SHARED_OBJECT_ID = 1 << 16,
+  JS_FUNCTION = 1 << 17,
+  ANY = 1 << 18
 };
 } // namespace expo

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

@@ -70,6 +70,9 @@ std::string ExpectedType::getJClassString(bool allowsPrimitives) {
   if (type == CppType::READABLE_MAP) {
     return "com/facebook/react/bridge/ReadableNativeMap";
   }
+  if (type == CppType::UINT8_TYPED_ARRAY) {
+    return "[B";
+  }
   if (type == CppType::TYPED_ARRAY) {
     return "expo/modules/kotlin/jni/JavaScriptTypedArray";
   }

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

@@ -153,6 +153,33 @@ bool ReadableNativeMapArrayFrontendConverter::canConvert(
   return value.isObject();
 }
 
+jobject ByteArrayFrontendConverter::convert(
+  jsi::Runtime &rt,
+  JNIEnv *env,
+  JSIInteropModuleRegistry *moduleRegistry,
+  const jsi::Value &value
+) const {
+  auto typedArray = TypedArray(rt, value.getObject(rt));
+  size_t length = typedArray.byteLength(rt);
+  auto byteArray = jni::JArrayByte::newArray(length);
+  byteArray->setRegion(0, length, static_cast<const signed char *>(typedArray.getRawPointer(rt)));
+  return byteArray.release();
+}
+
+bool ByteArrayFrontendConverter::canConvert(
+  jsi::Runtime &rt,
+  const jsi::Value &value
+) const {
+  if (value.isObject()) {
+    auto object = value.getObject(rt);
+    if (isTypedArray(rt, object)) {
+      auto typedArray = TypedArray(rt, object);
+      return typedArray.getKind(rt) == TypedArrayKind::Uint8Array;
+    }
+  }
+  return false;
+}
+
 jobject TypedArrayFrontendConverter::convert(
   jsi::Runtime &rt,
   JNIEnv *env,

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

@@ -160,6 +160,21 @@ public:
   bool canConvert(jsi::Runtime &rt, const jsi::Value &value) const override;
 };
 
+/**
+ * Converter from js Uint8Array to [java.lang.Byte] array.
+ */
+class ByteArrayFrontendConverter : 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 type array to [expo.modules.kotlin.jni.JavaScriptTypedArray].
  */

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

@@ -16,6 +16,7 @@ void FrontendConverterProvider::createConverters() {
   RegisterConverter(CppType::FLOAT, FloatFrontendConverter);
   RegisterConverter(CppType::DOUBLE, DoubleFrontendConverter);
   RegisterConverter(CppType::BOOLEAN, BooleanFrontendConverter);
+  RegisterConverter(CppType::UINT8_TYPED_ARRAY, ByteArrayFrontendConverter);
   RegisterConverter(CppType::TYPED_ARRAY, TypedArrayFrontendConverter);
   RegisterConverter(CppType::JS_OBJECT, JavaScriptObjectFrontendConverter);
   RegisterConverter(CppType::JS_VALUE, JavaScriptValueFrontendConverter);

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

@@ -11,6 +11,44 @@
 
 namespace react = facebook::react;
 
+namespace {
+
+// This value should be synced with the value in **FollyDynamicExtensionConverter.kt**
+constexpr char DYNAMIC_EXTENSION_PREFIX[] = "__expo_dynamic_extension__#";
+
+/**
+ * Create an JavaScript Uint8Array instance from Java ByteArray.
+ */
+jsi::Value createUint8Array(jsi::Runtime &rt, jni::alias_ref<jni::JArrayByte> byteArray) {
+  auto arrayBufferCtor = rt.global().getPropertyAsFunction(rt, "ArrayBuffer");
+  auto arrayBufferObject = arrayBufferCtor.callAsConstructor(rt, static_cast<int>(byteArray->size())).getObject(rt);
+  auto arrayBuffer = arrayBufferObject.getArrayBuffer(rt);
+  byteArray->getRegion(0, byteArray->size(), reinterpret_cast<signed char *>(arrayBuffer.data(rt)));
+
+  auto uint8ArrayCtor = rt.global().getPropertyAsFunction(rt, "Uint8Array");
+  auto uint8Array = uint8ArrayCtor.callAsConstructor(rt, arrayBufferObject).getObject(rt);
+  return uint8Array;
+}
+
+/**
+ * Convert a string with FollyDynamicExtensionConverter support.
+ */
+std::optional<jsi::Value> convertStringToFollyDynamicIfNeeded(jsi::Runtime &rt, const std::string& string) {
+  if (!string.starts_with(DYNAMIC_EXTENSION_PREFIX)) {
+    return std::nullopt;
+  }
+  auto converterClass = jni::findClassLocal("expo/modules/kotlin/types/folly/FollyDynamicExtensionConverter");
+  const auto getInstanceMethod = converterClass->getStaticMethod<jni::JObject(std::string)>("get");
+  jni::local_ref<jni::JObject> instance = getInstanceMethod(converterClass, string);
+
+  if (instance->isInstanceOf(jni::JArrayByte::javaClassStatic())) {
+    return createUint8Array(rt, jni::static_ref_cast<jni::JArrayByte>(instance));
+  }
+  return std::nullopt;
+}
+
+} // namespace
+
 namespace expo {
 
 jsi::Value convert(
@@ -34,10 +72,9 @@ jsi::Value convert(
     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()
-    );
+    std::string string = jni::static_ref_cast<jni::JString>(value)->toStdString();
+    auto enhancedValue = convertStringToFollyDynamicIfNeeded(rt, string);
+    return enhancedValue ? std::move(*enhancedValue) : jsi::String::createFromUtf8(rt, string);
   }
   if (env->IsInstanceOf(unpackedValue, cache->getJClass("java/lang/Boolean").clazz)) {
     return {(bool) jni::static_ref_cast<jni::JBoolean>(value)->value()};
@@ -52,7 +89,12 @@ jsi::Value convert(
     auto dynamic = jni::static_ref_cast<react::WritableNativeArray::javaobject>(value)
       ->cthis()
       ->consume();
-    return jsi::valueFromDynamic(rt, dynamic);
+    auto arg = jsi::valueFromDynamic(rt, dynamic);
+    auto enhancedArg = decorateValueForDynamicExtension(rt, arg);
+    if (enhancedArg) {
+      arg = std::move(*enhancedArg);
+    }
+    return arg;
   }
   if (env->IsInstanceOf(
     unpackedValue,
@@ -61,7 +103,12 @@ jsi::Value convert(
     auto dynamic = jni::static_ref_cast<react::WritableNativeMap::javaobject>(value)
       ->cthis()
       ->consume();
-    return jsi::valueFromDynamic(rt, dynamic);
+    auto arg = jsi::valueFromDynamic(rt, dynamic);
+    auto enhancedArg = decorateValueForDynamicExtension(rt, arg);
+    if (enhancedArg) {
+      arg = std::move(*enhancedArg);
+    }
+    return arg;
   }
   if (env->IsInstanceOf(unpackedValue, JavaScriptModuleObject::javaClassStatic().get())) {
     auto anonymousObject = jni::static_ref_cast<JavaScriptModuleObject::javaobject>(value)
@@ -106,4 +153,44 @@ jsi::Value convert(
 
   return jsi::Value::undefined();
 }
+
+std::optional<jsi::Value> decorateValueForDynamicExtension(jsi::Runtime &rt, const jsi::Value &value) {
+  if (value.isString()) {
+    std::string string = value.getString(rt).utf8(rt);
+    return convertStringToFollyDynamicIfNeeded(rt, string);
+  }
+
+  if (value.isObject()) {
+    auto jsObject = value.getObject(rt);
+    if (jsObject.isArray(rt)) {
+      bool changed = false;
+      auto jsArray = jsObject.getArray(rt);
+      size_t length = jsArray.length(rt);
+      for (size_t i = 0; i < length; ++i) {
+        auto converted = decorateValueForDynamicExtension(rt, jsArray.getValueAtIndex(rt, i));
+        if (converted) {
+          jsArray.setValueAtIndex(rt, i, std::move(*converted));
+          changed = true;
+        }
+      }
+      return changed ? std::make_optional<jsi::Value>(std::move(jsArray)) : std::nullopt;
+    } else {
+      bool changed = false;
+      auto propNames = jsObject.getPropertyNames(rt);
+      size_t length = propNames.length(rt);
+      for (size_t i = 0; i < length; ++i) {
+        auto propName = propNames.getValueAtIndex(rt, i).getString(rt);
+        auto converted = decorateValueForDynamicExtension(rt, jsObject.getProperty(rt, propName));
+        if (converted) {
+          jsObject.setProperty(rt, propName, std::move(*converted));
+          changed = true;
+        }
+      }
+      return changed ? std::make_optional<jsi::Value>(std::move(jsObject)) : std::nullopt;
+    }
+  }
+
+  return std::nullopt;
+}
+
 } // namespace expo

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

@@ -6,6 +6,7 @@
 
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
+#include <optional>
 
 namespace jni = facebook::jni;
 namespace jsi = facebook::jsi;
@@ -19,4 +20,9 @@ jsi::Value convert(
   jni::local_ref<jobject> value
 );
 
+/**
+ * Decorate jsi::Value with FollyDynamicExtensionConverter support.
+ */
+std::optional<jsi::Value> decorateValueForDynamicExtension(jsi::Runtime &rt, const jsi::Value &value);
+
 } // namespace expo

package/android/src/main/java/expo/modules/adapters/react/permissions/PermissionsService.kt

@@ -64,7 +64,7 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
     getPermissions(
       PermissionsResponseListener { permissionsMap: MutableMap<String, PermissionsResponse> ->
         val areAllGranted = permissionsMap.all { (_, response) -> response.status == PermissionsStatus.GRANTED }
-        val areAllDenied = permissionsMap.all { (_, response) -> response.status == PermissionsStatus.DENIED }
+        val areAllDenied = permissionsMap.isNotEmpty() && permissionsMap.all { (_, response) -> response.status == PermissionsStatus.DENIED }
         val canAskAgain = permissionsMap.all { (_, response) -> response.canAskAgain }
 
         promise.resolve(
@@ -113,6 +113,11 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
 
   @Throws(IllegalStateException::class)
   override fun askForPermissions(responseListener: PermissionsResponseListener, vararg permissions: String) {
+    if (permissions.isEmpty()) {
+      responseListener.onResult(mutableMapOf())
+      return
+    }
+
     if (permissions.contains(Manifest.permission.WRITE_SETTINGS)) {
       val permissionsToAsk = permissions.toMutableList().apply { remove(Manifest.permission.WRITE_SETTINGS) }.toTypedArray()
       val newListener = PermissionsResponseListener {
@@ -136,6 +141,11 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
         addToAskedPermissionsCache(arrayOf(Manifest.permission.WRITE_SETTINGS))
         askForWriteSettingsPermissionFirst()
       } else {
+        // User only ask for `WRITE_SETTINGS`, we can already return response
+        if (permissionsToAsk.isEmpty()) {
+          newListener.onResult(mutableMapOf())
+          return
+        }
         askForManifestPermissions(permissionsToAsk, newListener)
       }
     } else {

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

@@ -295,6 +295,9 @@ class AppContext(
     modulesQueue.cancel(ContextDestroyedException())
     mainQueue.cancel(ContextDestroyedException())
     backgroundCoroutineScope.cancel(ContextDestroyedException())
+    if (::jsiInterop.isInitialized) {
+      jsiInterop.wasDeallocated()
+    }
     jniDeallocator.deallocate()
     logger.info("✅ AppContext was destroyed")
   }

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

@@ -15,7 +15,7 @@ import expo.modules.kotlin.tracing.trace
 import kotlinx.coroutines.launch
 import kotlin.reflect.KClass
 
-class ModuleHolder(val module: Module) {
+class ModuleHolder<T : Module>(val module: T) {
   val definition = module.definition()
 
   val name get() = definition.name

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

@@ -12,11 +12,11 @@ import java.lang.ref.WeakReference
 
 class ModuleRegistry(
   private val appContext: WeakReference<AppContext>
-) : Iterable<ModuleHolder> {
+) : Iterable<ModuleHolder<*>> {
   @PublishedApi
-  internal val registry = mutableMapOf<String, ModuleHolder>()
+  internal val registry = mutableMapOf<String, ModuleHolder<*>>()
 
-  fun register(module: Module) = trace("ModuleRegistry.register(${module.javaClass})") {
+  fun <T : Module> register(module: T) = trace("ModuleRegistry.register(${module.javaClass})") {
     module._appContext = requireNotNull(appContext.get()) { "Cannot create a module for invalid app context." }
 
     val holder = ModuleHolder(module)
@@ -56,12 +56,13 @@ class ModuleRegistry(
     return registry.values.find { it.module is T }?.module as? T
   }
 
-  fun getModuleHolder(name: String): ModuleHolder? = registry[name]
+  fun getModuleHolder(name: String): ModuleHolder<*>? = registry[name]
 
-  fun getModuleHolder(module: Module): ModuleHolder? =
-    registry.values.find { it.module === module }
+  @Suppress("UNCHECKED_CAST")
+  fun <T : Module> getModuleHolder(module: T): ModuleHolder<T>? =
+    registry.values.find { it.module === module } as? ModuleHolder<T>
 
-  fun <T : View> getModuleHolder(viewClass: Class<T>): ModuleHolder? {
+  fun <T : View> getModuleHolder(viewClass: Class<T>): ModuleHolder<*>? {
     return registry.firstNotNullOfOrNull { (_, holder) ->
       if (holder.definition.viewManagerDefinition?.viewType == viewClass) {
         holder
@@ -91,7 +92,7 @@ class ModuleRegistry(
     }
   }
 
-  override fun iterator(): Iterator<ModuleHolder> = registry.values.iterator()
+  override fun iterator(): Iterator<ModuleHolder<*>> = registry.values.iterator()
 
   fun cleanUp() {
     registry.clear()

package/android/src/main/java/expo/modules/kotlin/events/KModuleEventEmitterWrapper.kt

@@ -17,7 +17,7 @@ import java.lang.ref.WeakReference
  * But because of that, we had to create a wrapper for EventEmitter.
  */
 class KModuleEventEmitterWrapper(
-  private val moduleHolder: ModuleHolder,
+  private val moduleHolder: ModuleHolder<*>,
   legacyEventEmitter: expo.modules.core.interfaces.services.EventEmitter,
   reactContextHolder: WeakReference<ReactApplicationContext>
 ) : KEventEmitterWrapper(legacyEventEmitter, reactContextHolder) {

package/android/src/main/java/expo/modules/kotlin/functions/AnyFunction.kt

@@ -50,7 +50,7 @@ abstract class AnyFunction(
   /**
    * A minimum number of arguments the functions needs which equals to `argumentsCount` reduced by the number of trailing optional arguments.
    */
-  internal val requiredArgumentsCount = run {
+  private val requiredArgumentsCount = run {
     val nonNullableArgIndex = desiredArgsTypes
       .reversed()
       .indexOfFirst { !it.kType.isMarkedNullable }

package/android/src/main/java/expo/modules/kotlin/functions/AsyncFunction.kt

@@ -1,5 +1,6 @@
 package expo.modules.kotlin.functions
 
+import android.view.View
 import com.facebook.react.bridge.ReadableArray
 import expo.modules.BuildConfig
 import expo.modules.kotlin.AppContext
@@ -22,7 +23,7 @@ abstract class AsyncFunction(
   desiredArgsTypes: Array<AnyType>
 ) : BaseAsyncFunctionComponent(name, desiredArgsTypes) {
 
-  override fun call(holder: ModuleHolder, args: ReadableArray, promise: Promise) {
+  override fun call(holder: ModuleHolder<*>, args: ReadableArray, promise: Promise) {
     val queue = when (queue) {
       Queues.MAIN -> holder.module.appContext.mainQueue
       Queues.DEFAULT -> null
@@ -85,24 +86,32 @@ abstract class AsyncFunction(
         }
       }
 
-      if (queue == Queues.MAIN) {
-        if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+      dispatchOnQueue(appContext, functionBody)
+    }
+  }
+
+  private fun dispatchOnQueue(appContext: AppContext, block: () -> Unit) {
+    when (queue) {
+      Queues.DEFAULT -> {
+        appContext.modulesQueue.launch {
+          block()
+        }
+      }
+
+      Queues.MAIN -> {
+        if (!BuildConfig.IS_NEW_ARCHITECTURE_ENABLED && desiredArgsTypes.any { it.inheritFrom<View>() }) {
           // On certain occasions, invoking a function on a view could lead to an error
           // because of the asynchronous communication between the JavaScript and native components.
           // In such cases, the native view may not have been mounted yet,
           // but the JavaScript code has already received the future tag of the view.
           // To avoid this issue, we have decided to temporarily utilize
           // the UIManagerModule for dispatching functions on the main thread.
-          appContext.dispatchOnMainUsingUIManager(functionBody)
-          return@registerAsyncFunction
+          appContext.dispatchOnMainUsingUIManager(block)
+          return
         }
 
         appContext.mainQueue.launch {
-          functionBody()
-        }
-      } else {
-        appContext.modulesQueue.launch {
-          functionBody()
+          block()
         }
       }
     }

package/android/src/main/java/expo/modules/kotlin/functions/BaseAsyncFunctionComponent.kt

@@ -17,7 +17,7 @@ abstract class BaseAsyncFunctionComponent(
 
   protected var queue = Queues.DEFAULT
 
-  abstract fun call(holder: ModuleHolder, args: ReadableArray, promise: Promise)
+  abstract fun call(holder: ModuleHolder<*>, args: ReadableArray, promise: Promise)
 
   fun runOnQueue(queue: Queues) = apply {
     this.queue = queue

package/android/src/main/java/expo/modules/kotlin/functions/SuspendFunctionComponent.kt

@@ -22,7 +22,7 @@ class SuspendFunctionComponent(
   private val body: suspend CoroutineScope.(args: Array<out Any?>) -> Any?
 ) : BaseAsyncFunctionComponent(name, desiredArgsTypes) {
 
-  override fun call(holder: ModuleHolder, args: ReadableArray, promise: Promise) {
+  override fun call(holder: ModuleHolder<*>, args: ReadableArray, promise: Promise) {
     val appContext = holder.module.appContext
     val queue = when (queue) {
       Queues.MAIN -> appContext.mainQueue

package/android/src/main/java/expo/modules/kotlin/jni/CppType.kt

@@ -24,6 +24,7 @@ enum class CppType(val clazz: KClass<*>, val value: Int = nextValue()) {
   JS_VALUE(JavaScriptValue::class),
   READABLE_ARRAY(ReadableArray::class),
   READABLE_MAP(ReadableMap::class),
+  UINT8_TYPED_ARRAY(ByteArray::class),
   TYPED_ARRAY(TypedArray::class),
   PRIMITIVE_ARRAY(Array::class),
   LIST(List::class),

package/android/src/main/java/expo/modules/kotlin/jni/JSIInteropModuleRegistry.kt

@@ -68,6 +68,11 @@ class JSIInteropModuleRegistry(appContext: AppContext) : Destructible {
    */
   external fun drainJSEventLoop()
 
+  /**
+   * Informs C++ that runtime was deallocated.
+   */
+  external fun wasDeallocated()
+
   /**
    * Returns a `JavaScriptModuleObject` that is a bridge between [expo.modules.kotlin.modules.Module]
    * and HostObject exported via JSI.