expo-modules-core 1.3.2 → 1.5.0

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

@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include "JNIDeallocator.h"
+
 #include <jsi/jsi.h>
 #include <fbjni/fbjni.h>
 #include <ReactCommon/CallInvoker.h>
@@ -65,19 +67,19 @@ public:
    * @throws if the input format is unknown, or evaluation causes an error,
    * a jni::JniException<JavaScriptEvaluateException> will be thrown.
    */
-  jni::local_ref<jni::HybridClass<JavaScriptValue>::javaobject> evaluateScript(
+  jni::local_ref<jni::HybridClass<JavaScriptValue, Destructible>::javaobject> evaluateScript(
     const std::string &script
   );
 
   /**
    * Returns the runtime global object for use in Kotlin.
    */
-  jni::local_ref<jni::HybridClass<JavaScriptObject>::javaobject> global();
+  jni::local_ref<jni::HybridClass<JavaScriptObject, Destructible>::javaobject> global();
 
   /**
    * Creates a new object for use in Kotlin.
    */
-  jni::local_ref<jni::HybridClass<JavaScriptObject>::javaobject> createObject();
+  jni::local_ref<jni::HybridClass<JavaScriptObject, Destructible>::javaobject> createObject();
 
   /**
    * Drains the JavaScript VM internal Microtask (a.k.a. event loop) queue.

package/android/src/main/cpp/JavaScriptTypedArray.cpp

@@ -1,6 +1,7 @@
 #include "JavaScriptTypedArray.h"
 
 #include "JavaScriptRuntime.h"
+#include "JSIInteropModuleRegistry.h"
 
 namespace expo {
 
@@ -88,4 +89,17 @@ void JavaScriptTypedArray::writeBuffer(
   auto region = buffer->getRegion(0, size);
   memcpy(rawPointer + position, region.get(), size);
 }
+
+jni::local_ref<JavaScriptTypedArray::javaobject> JavaScriptTypedArray::newInstance(
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Object> jsObject
+) {
+  auto object = JavaScriptTypedArray::newObjectCxxArgs(
+    std::move(runtime),
+    std::move(jsObject)
+  );
+  jsiInteropModuleRegistry->jniDeallocator->addReference(object);
+  return object;
+}
 }

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

@@ -25,6 +25,12 @@ public:
 
   static void registerNatives();
 
+  static jni::local_ref<JavaScriptTypedArray::javaobject> newInstance(
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Object> jsObject
+  );
+
   JavaScriptTypedArray(
     std::weak_ptr<JavaScriptRuntime> runtime,
     std::shared_ptr<jsi::Object> jsObject

package/android/src/main/cpp/JavaScriptValue.cpp

@@ -8,6 +8,7 @@
 #include "JavaScriptFunction.h"
 #include "TypedArray.h"
 #include "Exceptions.h"
+#include "JSIInteropModuleRegistry.h"
 
 namespace expo {
 void JavaScriptValue::registerNatives() {
@@ -155,18 +156,27 @@ std::string JavaScriptValue::getString() {
 jni::local_ref<JavaScriptObject::javaobject> JavaScriptValue::getObject() {
   auto &jsRuntime = runtimeHolder.getJSRuntime();
   auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(jsRuntime));
-  return JavaScriptObject::newObjectCxxArgs(runtimeHolder, jsObject);
+  return JavaScriptObject::newInstance(
+    runtimeHolder.getModuleRegistry(),
+    runtimeHolder,
+    jsObject
+  );
 }
 
 jni::local_ref<JavaScriptFunction::javaobject> JavaScriptValue::jniGetFunction() {
   auto &jsRuntime = runtimeHolder.getJSRuntime();
   auto jsFunction = std::make_shared<jsi::Function>(
     jsValue->getObject(jsRuntime).asFunction(jsRuntime));
-  return JavaScriptFunction::newObjectCxxArgs(runtimeHolder, jsFunction);
+  return JavaScriptFunction::newInstance(
+    runtimeHolder.getModuleRegistry(),
+    runtimeHolder,
+    jsFunction
+  );
 }
 
 jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptValue::getArray() {
   auto &jsRuntime = runtimeHolder.getJSRuntime();
+  auto moduleRegistry = runtimeHolder.getModuleRegistry();
 
   auto jsArray = jsValue
     ->getObject(jsRuntime)
@@ -175,7 +185,8 @@ jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> JavaScriptValue::g
 
   auto result = jni::JArrayClass<JavaScriptValue::javaobject>::newArray(size);
   for (size_t i = 0; i < size; i++) {
-    auto element = JavaScriptValue::newObjectCxxArgs(
+    auto element = JavaScriptValue::newInstance(
+      moduleRegistry,
       runtimeHolder,
       std::make_shared<jsi::Value>(jsArray.getValueAtIndex(jsRuntime, i))
     );
@@ -198,6 +209,23 @@ jni::local_ref<jstring> JavaScriptValue::jniGetString() {
 jni::local_ref<JavaScriptTypedArray::javaobject> JavaScriptValue::getTypedArray() {
   auto &jsRuntime = runtimeHolder.getJSRuntime();
   auto jsObject = std::make_shared<jsi::Object>(jsValue->getObject(jsRuntime));
-  return JavaScriptTypedArray::newObjectCxxArgs(runtimeHolder, jsObject);
+  return JavaScriptTypedArray::newInstance(
+    runtimeHolder.getModuleRegistry(),
+    runtimeHolder,
+    jsObject
+  );
+}
+
+jni::local_ref<JavaScriptValue::javaobject> JavaScriptValue::newInstance(
+  JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+  std::weak_ptr<JavaScriptRuntime> runtime,
+  std::shared_ptr<jsi::Value> jsValue
+) {
+  auto value = JavaScriptValue::newObjectCxxArgs(
+    std::move(runtime),
+    std::move(jsValue)
+  );
+  jsiInteropModuleRegistry->jniDeallocator->addReference(value);
+  return value;
 }
 } // namespace expo

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

@@ -5,6 +5,7 @@
 #include "JSIObjectWrapper.h"
 #include "WeakRuntimeHolder.h"
 #include "JavaScriptTypedArray.h"
+#include "JNIDeallocator.h"
 
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
@@ -26,7 +27,7 @@ class JavaScriptFunction;
 /**
  * Represents any JavaScript value. Its purpose is to expose the `jsi::Value` API back to Kotlin.
  */
-class JavaScriptValue : public jni::HybridClass<JavaScriptValue>, JSIValueWrapper {
+class JavaScriptValue : public jni::HybridClass<JavaScriptValue, Destructible>, JSIValueWrapper {
 public:
   static auto constexpr
     kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaScriptValue;";
@@ -34,6 +35,12 @@ public:
 
   static void registerNatives();
 
+  static jni::local_ref<JavaScriptValue::javaobject> newInstance(
+    JSIInteropModuleRegistry *jsiInteropModuleRegistry,
+    std::weak_ptr<JavaScriptRuntime> runtime,
+    std::shared_ptr<jsi::Value> jsValue
+  );
+
   JavaScriptValue(
     std::weak_ptr<JavaScriptRuntime> runtime,
     std::shared_ptr<jsi::Value> jsValue
@@ -74,13 +81,13 @@ public:
 
   std::string getString();
 
-  jni::local_ref<jni::HybridClass<JavaScriptObject>::javaobject> getObject();
+  jni::local_ref<jni::HybridClass<JavaScriptObject, Destructible>::javaobject> getObject();
 
   jni::local_ref<jni::JArrayClass<JavaScriptValue::javaobject>> getArray();
 
   jni::local_ref<JavaScriptTypedArray::javaobject> getTypedArray();
 
-  jni::local_ref<jni::HybridClass<JavaScriptFunction>::javaobject> jniGetFunction();
+  jni::local_ref<jni::HybridClass<JavaScriptFunction, Destructible>::javaobject> jniGetFunction();
 
 private:
   friend HybridBase;

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

@@ -102,7 +102,7 @@ jni::local_ref<JavaCallback::JavaPart> createJavaCallbackFromJSIFunction(
       wrapperWasCalled = true;
     };
 
-  return JavaCallback::newObjectCxxArgs(std::move(fn));
+  return JavaCallback::newInstance(moduleRegistry, std::move(fn));
 }
 
 jobjectArray MethodMetadata::convertJSIArgsToJNI(

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

@@ -159,7 +159,8 @@ jobject TypedArrayFrontendConverter::convert(
   JSIInteropModuleRegistry *moduleRegistry,
   const jsi::Value &value
 ) const {
-  return JavaScriptTypedArray::newObjectCxxArgs(
+  return JavaScriptTypedArray::newInstance(
+    moduleRegistry,
     moduleRegistry->runtimeHolder->weak_from_this(),
     std::make_shared<jsi::Object>(value.getObject(rt))
   ).release();
@@ -178,7 +179,8 @@ jobject JavaScriptValueFrontendConverter::convert(
   JSIInteropModuleRegistry *moduleRegistry,
   const jsi::Value &value
 ) const {
-  return JavaScriptValue::newObjectCxxArgs(
+  return JavaScriptValue::newInstance(
+    moduleRegistry,
     moduleRegistry->runtimeHolder->weak_from_this(),
     // TODO(@lukmccall): make sure that copy here is necessary
     std::make_shared<jsi::Value>(jsi::Value(rt, value))
@@ -195,7 +197,8 @@ jobject JavaScriptObjectFrontendConverter::convert(
   JSIInteropModuleRegistry *moduleRegistry,
   const jsi::Value &value
 ) const {
-  return JavaScriptObject::newObjectCxxArgs(
+  return JavaScriptObject::newInstance(
+    moduleRegistry,
     moduleRegistry->runtimeHolder->weak_from_this(),
     std::make_shared<jsi::Object>(value.getObject(rt))
   ).release();
@@ -214,7 +217,8 @@ jobject JavaScriptFunctionFrontendConverter::convert(
   JSIInteropModuleRegistry *moduleRegistry,
   const jsi::Value &value
 ) const {
-  return JavaScriptFunction::newObjectCxxArgs(
+  return JavaScriptFunction::newInstance(
+    moduleRegistry,
     moduleRegistry->runtimeHolder->weak_from_this(),
     std::make_shared<jsi::Function>(value.getObject(rt).asFunction(rt))
   ).release();

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

@@ -6,6 +6,7 @@ import android.view.ViewGroup;
 
 import com.facebook.react.ReactActivity;
 import com.facebook.react.ReactActivityDelegate;
+import com.facebook.react.ReactNativeHost;
 import com.facebook.react.ReactRootView;
 
 import androidx.annotation.Nullable;
@@ -54,4 +55,17 @@ public interface ReactActivityHandler {
   default ReactActivityDelegate onDidCreateReactActivityDelegate(ReactActivity activity, ReactActivityDelegate delegate) {
     return null;
   }
+
+  /**
+   * For modules to delay the call for react-native `loadApp`.
+   * This gives modules a chance to do some early and heavy initialization in background thread and avoid ANR.
+   * Right now it is for expo-updates only.
+   */
+  @Nullable
+  default DelayLoadAppHandler getDelayLoadAppHandler(ReactActivity activity, ReactNativeHost reactNativeHost) {
+    return null;
+  }
+  interface DelayLoadAppHandler {
+    void whenReady(Runnable runnable);
+  }
 }

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

@@ -91,6 +91,8 @@ class AppContext(
       CoroutineName("expo.modules.MainQueue")
   )
 
+  val jniDeallocator: JNIDeallocator = JNIDeallocator()
+
   internal var legacyModulesProxyHolder: WeakReference<NativeModulesProxy>? = null
 
   private val activityResultsManager = ActivityResultsManager(this)
@@ -130,6 +132,7 @@ class AppContext(
         ?.let {
           jsiInterop.installJSI(
             it,
+            jniDeallocator,
             jsContextProvider.jsCallInvokerHolder,
             catalystInstance.nativeCallInvokerHolder as CallInvokerHolderImpl
           )
@@ -275,7 +278,7 @@ class AppContext(
     modulesQueue.cancel(ContextDestroyedException())
     mainQueue.cancel(ContextDestroyedException())
     backgroundCoroutineScope.cancel(ContextDestroyedException())
-    JNIDeallocator.deallocate()
+    jniDeallocator.deallocate()
     logger.info("✅ AppContext was destroyed")
   }
 

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

@@ -24,13 +24,16 @@ class ModuleHolder(val module: Module) {
    */
   val jsObject by lazy {
     val appContext = module.appContext
+    val jniDeallocator = appContext.jniDeallocator
 
-    JavaScriptModuleObject(name).apply {
+    JavaScriptModuleObject(jniDeallocator, name).apply {
       initUsingObjectDefinition(appContext, definition.objectDefinition)
 
       val viewFunctions = definition.viewManagerDefinition?.asyncFunctions
       if (viewFunctions?.isNotEmpty() == true) {
-        val viewPrototype = JavaScriptModuleObject("${name}_${definition.viewManagerDefinition?.viewType?.name}")
+        val viewPrototype = JavaScriptModuleObject(jniDeallocator, "${name}_${definition.viewManagerDefinition?.viewType?.name}")
+        appContext.jniDeallocator.addReference(viewPrototype)
+
         viewFunctions.forEach { function ->
           function.attachToJSObject(appContext, viewPrototype)
         }
@@ -39,8 +42,9 @@ class ModuleHolder(val module: Module) {
       }
 
       definition.classData.forEach { clazz ->
-        val clazzModuleObject = JavaScriptModuleObject(clazz.name)
+        val clazzModuleObject = JavaScriptModuleObject(jniDeallocator, clazz.name)
           .initUsingObjectDefinition(module.appContext, clazz.objectDefinition)
+        appContext.jniDeallocator.addReference(clazzModuleObject)
 
         val constructor = clazz.constructor
         registerClass(

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

@@ -17,8 +17,10 @@ class ModuleRegistry(
   internal val registry = mutableMapOf<String, ModuleHolder>()
 
   fun register(module: Module) {
-    val holder = ModuleHolder(module)
     module._appContext = requireNotNull(appContext.get()) { "Cannot create a module for invalid app context." }
+
+    val holder = ModuleHolder(module)
+
     module.coroutineScopeDelegate = lazy {
       CoroutineScope(
         Dispatchers.Default +
@@ -26,19 +28,24 @@ class ModuleRegistry(
           CoroutineName(holder.definition.name)
       )
     }
-    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
+
+    holder.apply {
+      post(EventName.MODULE_CREATE)
+      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.
+      viewClass()?.let { viewType ->
+        appContext.get()?.backgroundCoroutineScope?.launch {
+          viewType.declaredMemberProperties
+        }
       }
     }
+
     registry[holder.name] = holder
   }
 

package/android/src/main/java/expo/modules/kotlin/devtools/ExpoNetworkInspectOkHttpInterceptors.kt

@@ -0,0 +1,70 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.kotlin.devtools
+
+import okhttp3.Interceptor
+import okhttp3.Request
+import okhttp3.Response
+
+// Currently keeps the delegate fixed for ExpoRequestCdpInterceptor and be thread-safe
+internal val delegate: ExpoNetworkInspectOkHttpInterceptorsDelegate = ExpoRequestCdpInterceptor
+
+/**
+ * The OkHttp network interceptor to log requests and the CDP events to the delegate
+ */
+@Suppress("unused")
+class ExpoNetworkInspectOkHttpNetworkInterceptor : Interceptor {
+  override fun intercept(chain: Interceptor.Chain): Response {
+    val request = chain.request()
+    val redirectResponse = request.tag(RedirectResponse::class.java)
+    val requestId = redirectResponse?.requestId ?: request.hashCode().toString()
+    delegate.willSendRequest(requestId, request, redirectResponse?.priorResponse)
+
+    val response = chain.proceed(request)
+
+    if (response.isRedirect) {
+      response.request.tag(RedirectResponse::class.java)?.let {
+        it.requestId = requestId
+        it.priorResponse = response
+      }
+    } else {
+      delegate.didReceiveResponse(requestId, request, response)
+    }
+    return response
+  }
+
+  companion object {
+    const val MAX_BODY_SIZE = 1048576L
+  }
+}
+
+/**
+ * The OkHttp app interceptor to add custom tag for [RedirectResponse]
+ */
+@Suppress("unused")
+class ExpoNetworkInspectOkHttpAppInterceptor : Interceptor {
+  override fun intercept(chain: Interceptor.Chain): Response {
+    return chain.proceed(
+      chain.request().newBuilder()
+        .tag(RedirectResponse::class.java, RedirectResponse())
+        .build()
+    )
+  }
+}
+
+/**
+ * The delegate to dispatch network request events
+ */
+internal interface ExpoNetworkInspectOkHttpInterceptorsDelegate {
+  fun willSendRequest(requestId: String, request: Request, redirectResponse: Response?)
+
+  fun didReceiveResponse(requestId: String, request: Request, response: Response)
+}
+
+/**
+ * Custom property for redirect requests
+ */
+internal class RedirectResponse {
+  var requestId: String? = null
+  var priorResponse: Response? = null
+}

package/android/src/main/java/expo/modules/kotlin/devtools/ExpoRequestCdpInterceptor.kt

@@ -0,0 +1,72 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.kotlin.devtools
+
+import expo.modules.kotlin.devtools.cdp.Event
+import expo.modules.kotlin.devtools.cdp.ExpoReceivedResponseBodyParams
+import expo.modules.kotlin.devtools.cdp.LoadingFinishedParams
+import expo.modules.kotlin.devtools.cdp.RequestWillBeSentExtraInfoParams
+import expo.modules.kotlin.devtools.cdp.RequestWillBeSentParams
+import expo.modules.kotlin.devtools.cdp.ResponseReceivedParams
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import okhttp3.Request
+import okhttp3.Response
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+/**
+ * The `ExpoRequestInterceptorProtocolDelegate` implementation to
+ * dispatch CDP (Chrome DevTools Protocol: https://chromedevtools.github.io/devtools-protocol/) events.
+ */
+object ExpoRequestCdpInterceptor : ExpoNetworkInspectOkHttpInterceptorsDelegate {
+  private var delegate: Delegate? = null
+  internal var coroutineScope = CoroutineScope(Dispatchers.Default)
+
+  fun setDelegate(delegate: Delegate?) {
+    coroutineScope.launch {
+      this@ExpoRequestCdpInterceptor.delegate = delegate
+    }
+  }
+
+  private fun dispatchEvent(event: Event) {
+    coroutineScope.launch {
+      this@ExpoRequestCdpInterceptor.delegate?.dispatch(event.toJson())
+    }
+  }
+
+  //region ExpoNetworkInspectOkHttpInterceptorsDelegate implementations
+
+  override fun willSendRequest(requestId: String, request: Request, redirectResponse: Response?) {
+    val now = BigDecimal(System.currentTimeMillis() / 1000.0).setScale(3, RoundingMode.CEILING)
+
+    val params = RequestWillBeSentParams(now, requestId, request, redirectResponse)
+    dispatchEvent(Event("Network.requestWillBeSent", params))
+
+    val params2 = RequestWillBeSentExtraInfoParams(now, requestId, request)
+    dispatchEvent(Event("Network.requestWillBeSentExtraInfo", params2))
+  }
+
+  override fun didReceiveResponse(requestId: String, request: Request, response: Response) {
+    val now = BigDecimal(System.currentTimeMillis() / 1000.0).setScale(3, RoundingMode.CEILING)
+
+    val params = ResponseReceivedParams(now, requestId, request, response)
+    dispatchEvent(Event("Network.responseReceived", params))
+
+    val params2 = LoadingFinishedParams(now, requestId, request, response)
+    dispatchEvent(Event("Network.loadingFinished", params2))
+
+    val contentLength = response.body?.contentLength() ?: 0
+    if (contentLength >= 0 && contentLength <= ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE) {
+      val params3 = ExpoReceivedResponseBodyParams(now, requestId, request, response)
+      dispatchEvent(Event("Expo(Network.receivedResponseBody)", params3))
+    }
+  }
+
+  //endregion ExpoNetworkInspectOkHttpInterceptorsDelegate implementations
+
+  interface Delegate {
+    fun dispatch(event: String)
+  }
+}

package/android/src/main/java/expo/modules/kotlin/devtools/OkHttpHeadersExtension.kt

@@ -0,0 +1,18 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+package expo.modules.kotlin.devtools
+
+import androidx.collection.ArrayMap
+import okhttp3.Headers
+
+/**
+ * OkHttp `Headers` extension method to generate a simple key-value map
+ * which only exposing single value for a key.
+ */
+fun Headers.toSingleMap(): Map<String, String> {
+  val result = ArrayMap<String, String>()
+  for (key in names()) {
+    result[key] = get(key)
+  }
+  return result
+}