expo-modules-core 1.12.2 → 1.12.4

package/CHANGELOG.md

@@ -10,6 +10,19 @@
 
 ### 💡 Others
 
+## 1.12.4 — 2024-04-29
+
+### 🐛 Bug fixes
+
+- [Android] Fixed gziped payload does not correctly shown in network inspector. ([#28486](https://github.com/expo/expo/pull/28486) by [@kudo](https://github.com/kudo))
+- [Android] Fixed crashes during the deallocation of shared objects. ([#28491](https://github.com/expo/expo/pull/28491) by [@lukmccall](https://github.com/lukmccall))
+
+## 1.12.3 — 2024-04-26
+
+### 🐛 Bug fixes
+
+- [Android] Fixes SEGFAULTs caused by `std::shared_ptr<JavaCalllback::CallbackContext>::__on_zero_shared`. ([#28483](https://github.com/expo/expo/pull/28483) by [@lukmccall](https://github.com/lukmccall))
+
 ## 1.12.2 — 2024-04-23
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '1.12.2'
+version = '1.12.4'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -63,7 +63,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "1.12.2"
+    versionName "1.12.4"
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled.toString()
 
     testInstrumentationRunner "expo.modules.TestRunner"

package/android/src/main/cpp/JSIContext.cpp

@@ -29,6 +29,42 @@ namespace expo {
 
 #endif
 
+/*
+ * A wrapper for a global reference that can be deallocated on any thread.
+ * It should be used with smart pointer. That structure can't be copied or moved.
+ */
+template <typename T>
+class ThreadSafeJNIGlobalRef {
+public:
+  ThreadSafeJNIGlobalRef(jobject globalRef) : globalRef(globalRef) {}
+  ThreadSafeJNIGlobalRef(const ThreadSafeJNIGlobalRef &other) = delete;
+  ThreadSafeJNIGlobalRef(ThreadSafeJNIGlobalRef &&other) = delete;
+  ThreadSafeJNIGlobalRef &operator=(const ThreadSafeJNIGlobalRef &other) = delete;
+  ThreadSafeJNIGlobalRef &operator=(ThreadSafeJNIGlobalRef &&other) = delete;
+
+  void use(std::function<void(jni::alias_ref<T> globalRef)> &&action) {
+    if (globalRef == nullptr) {
+      throw std::runtime_error("ThreadSafeJNIGlobalRef: globalRef is null");
+    }
+
+    jni::ThreadScope::WithClassLoader([this, action = std::move(action)]() {
+      jni::alias_ref<jobject> aliasRef = jni::wrap_alias(globalRef);
+      jni::alias_ref<T> jsiContextRef = jni::static_ref_cast<T>(aliasRef);
+      action(jsiContextRef);
+    });
+  }
+
+  ~ThreadSafeJNIGlobalRef() {
+    if (globalRef != nullptr) {
+      jni::ThreadScope::WithClassLoader([this] {
+        jni::Environment::current()->DeleteGlobalRef(this->globalRef);
+      });
+    }
+  }
+
+  jobject globalRef;
+};
+
 jni::local_ref<JSIContext::jhybriddata>
 JSIContext::initHybrid(jni::alias_ref<jhybridobject> jThis) {
   return makeCxxInstance(jThis);
@@ -137,13 +173,17 @@ void JSIContext::prepareRuntime() {
 
   EventEmitter::installClass(runtime);
 
+  auto threadSafeRef = std::make_shared<ThreadSafeJNIGlobalRef<JSIContext::javaobject>>(
+    jni::Environment::current()->NewGlobalRef(javaPart_.get())
+  );
+
   SharedObject::installBaseClass(
     runtime,
     // We can't predict the order of deallocation of the JSIContext and the SharedObject.
     // So we need to pass a new ref to retain the JSIContext to make sure it's not deallocated before the SharedObject.
-    [javaObject = javaPart_](const SharedObject::ObjectId objectId) {
-      jni::ThreadScope::WithClassLoader([objectId = objectId, javaObject = std::move(javaObject)] {
-        JSIContext::deleteSharedObject(javaObject, objectId);
+    [threadSafeRef = std::move(threadSafeRef)](const SharedObject::ObjectId objectId) {
+      threadSafeRef->use([objectId](jni::alias_ref<JSIContext::javaobject> globalRef) {
+        JSIContext::deleteSharedObject(globalRef, objectId);
       });
     }
   );
@@ -169,7 +209,8 @@ void JSIContext::prepareRuntime() {
 jni::local_ref<JavaScriptModuleObject::javaobject>
 JSIContext::callGetJavaScriptModuleObjectMethod(const std::string &moduleName) const {
   if (javaPart_ == nullptr) {
-    throw std::runtime_error("getJavaScriptModuleObject: JSIContext was prepared to be deallocated.");
+    throw std::runtime_error(
+      "getJavaScriptModuleObject: JSIContext was prepared to be deallocated.");
   }
 
   const static auto method = expo::JSIContext::javaClassLocal()
@@ -270,7 +311,7 @@ void JSIContext::registerSharedObject(
 }
 
 void JSIContext::deleteSharedObject(
-  jni::global_ref<JSIContext::javaobject> javaObject,
+  jni::alias_ref<JSIContext::javaobject> javaObject,
   int objectId
 ) {
   if (javaObject == nullptr) {
@@ -324,13 +365,17 @@ void JSIContext::jniSetNativeStateForSharedObject(
   int id,
   jni::alias_ref<JavaScriptObject::javaobject> jsObject
 ) {
+  auto threadSafeRef = std::make_shared<ThreadSafeJNIGlobalRef<JSIContext::javaobject>>(
+    jni::Environment::current()->NewGlobalRef(javaPart_.get())
+  );
+
   auto nativeState = std::make_shared<expo::SharedObject::NativeState>(
     id,
     // We can't predict the order of deallocation of the JSIContext and the SharedObject.
     // So we need to pass a new ref to retain the JSIContext to make sure it's not deallocated before the SharedObject.
-    [javaObject = javaPart_](const SharedObject::ObjectId objectId) {
-      jni::ThreadScope::WithClassLoader([objectId = objectId, javaObject = std::move(javaObject)] {
-        JSIContext::deleteSharedObject(javaObject, objectId);
+    [threadSafeRef = std::move(threadSafeRef)](const SharedObject::ObjectId objectId) {
+      threadSafeRef->use([objectId](jni::alias_ref<JSIContext::javaobject> globalRef) {
+        JSIContext::deleteSharedObject(globalRef, objectId);
       });
     }
   );

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

@@ -123,7 +123,7 @@ public:
   );
 
   static void deleteSharedObject(
-    jni::global_ref<JSIContext::javaobject> javaObject,
+    jni::alias_ref<JSIContext::javaobject> javaObject,
     int objectId
   );
 

package/android/src/main/cpp/JavaCallback.cpp

@@ -13,6 +13,39 @@
 
 namespace expo {
 
+#if REACT_NATIVE_TARGET_VERSION >= 75
+
+JavaCallback::CallbackContext::CallbackContext(
+  jsi::Runtime &rt,
+  std::weak_ptr<react::CallInvoker> jsCallInvokerHolder,
+  std::optional<jsi::Function> resolveHolder,
+  std::optional<jsi::Function> rejectHolder
+) : react::LongLivedObject(rt),
+    rt(rt),
+    jsCallInvokerHolder(std::move(jsCallInvokerHolder)),
+    resolveHolder(std::move(resolveHolder)),
+    rejectHolder(std::move(rejectHolder)) {}
+
+#else
+
+JavaCallback::CallbackContext::CallbackContext(
+  jsi::Runtime &rt,
+  std::weak_ptr<react::CallInvoker> jsCallInvokerHolder,
+  std::optional<jsi::Function> resolveHolder,
+  std::optional<jsi::Function> rejectHolder
+) : rt(rt),
+    jsCallInvokerHolder(std::move(jsCallInvokerHolder)),
+    resolveHolder(std::move(resolveHolder)),
+    rejectHolder(std::move(rejectHolder)) {}
+
+#endif
+
+void JavaCallback::CallbackContext::invalidate() {
+  resolveHolder.reset();
+  rejectHolder.reset();
+  allowRelease();
+}
+
 JavaCallback::JavaCallback(std::shared_ptr<CallbackContext> callbackContext)
   : callbackContext(std::move(callbackContext)) {}
 
@@ -27,6 +60,7 @@ void JavaCallback::registerNatives() {
                    makeNativeMethod("invokeNative", JavaCallback::invokeArray),
                    makeNativeMethod("invokeNative", JavaCallback::invokeMap),
                    makeNativeMethod("invokeNative", JavaCallback::invokeSharedRef),
+                   makeNativeMethod("invokeNative", JavaCallback::invokeError),
                  });
 }
 
@@ -45,24 +79,41 @@ void JavaCallback::invokeJSFunction(
   ArgsConverter<T> argsConverter,
   T arg
 ) {
-  const auto jsInvoker = callbackContext->jsCallInvokerHolder;
+  const auto strongCallbackContext = this->callbackContext.lock();
+  // The context were deallocated before the callback was invoked.
+  if (strongCallbackContext == nullptr) {
+    return;
+  }
+
+  const auto jsInvoker = strongCallbackContext->jsCallInvokerHolder.lock();
+  // Call invoker is already released, so we cannot invoke the callback.
+  if (jsInvoker == nullptr) {
+    return;
+  }
+
   jsInvoker->invokeAsync(
     [
-      context = std::move(callbackContext),
+      context = callbackContext,
       argsConverter = std::move(argsConverter),
       arg = std::move(arg)
     ]() -> void {
-      if (!context->jsFunctionHolder.has_value()) {
+      auto strongContext = context.lock();
+      // The context were deallocated before the callback was invoked.
+      if (strongContext == nullptr) {
+        return;
+      }
+
+      if (!strongContext->resolveHolder.has_value()) {
         throw std::runtime_error(
           "JavaCallback was already settled. Cannot invoke it again"
         );
       }
 
-      jsi::Function &jsFunction = context->jsFunctionHolder.value();
-      jsi::Runtime &rt = context->rt;
+      jsi::Function &jsFunction = strongContext->resolveHolder.value();
+      jsi::Runtime &rt = strongContext->rt;
 
-      argsConverter(rt, jsFunction, std::move(arg), context->isRejectCallback);
-      context->jsFunctionHolder.reset();
+      argsConverter(rt, jsFunction, std::move(arg));
+      strongContext->invalidate();
     });
 }
 
@@ -72,8 +123,7 @@ void JavaCallback::invokeJSFunction(T arg) {
     [](
       jsi::Runtime &rt,
       jsi::Function &jsFunction,
-      T arg,
-      bool isRejectCallback
+      T arg
     ) {
       jsFunction.call(rt, {jsi::Value(rt, arg)});
     },
@@ -86,8 +136,7 @@ void JavaCallback::invoke() {
     [](
       jsi::Runtime &rt,
       jsi::Function &jsFunction,
-      nullptr_t arg,
-      bool isRejectCallback
+      nullptr_t arg
     ) {
       jsFunction.call(rt, {jsi::Value::null()});
     },
@@ -116,8 +165,7 @@ void JavaCallback::invokeString(jni::alias_ref<jstring> result) {
     [](
       jsi::Runtime &rt,
       jsi::Function &jsFunction,
-      std::string arg,
-      bool isRejectCallback
+      std::string arg
     ) {
       std::optional<jsi::Value> extendedString = convertStringToFollyDynamicIfNeeded(
         rt,
@@ -145,8 +193,7 @@ void JavaCallback::invokeArray(jni::alias_ref<react::WritableNativeArray::javaob
     [](
       jsi::Runtime &rt,
       jsi::Function &jsFunction,
-      folly::dynamic arg,
-      bool isRejectCallback
+      folly::dynamic arg
     ) {
       jsi::Value convertedArg = jsi::valueFromDynamic(rt, arg);
       auto enhancedArg = decorateValueForDynamicExtension(rt, convertedArg);
@@ -169,28 +216,8 @@ void JavaCallback::invokeMap(jni::alias_ref<react::WritableNativeMap::javaobject
     [](
       jsi::Runtime &rt,
       jsi::Function &jsFunction,
-      folly::dynamic arg,
-      bool isRejectCallback
+      folly::dynamic arg
     ) {
-      if (isRejectCallback) {
-        auto errorCode = arg.find("code")->second.asString();
-        auto message = arg.find("message")->second.asString();
-
-        auto codedError = makeCodedError(
-          rt,
-          jsi::String::createFromUtf8(rt, errorCode),
-          jsi::String::createFromUtf8(rt, message)
-        );
-
-        jsFunction.call(
-          rt,
-          (const jsi::Value *) &codedError,
-          (size_t) 1
-        );
-
-        return;
-      }
-
       jsi::Value convertedArg = jsi::valueFromDynamic(rt, arg);
       auto enhancedArg = decorateValueForDynamicExtension(rt, convertedArg);
       if (enhancedArg) {
@@ -212,8 +239,7 @@ void JavaCallback::invokeSharedRef(jni::alias_ref<SharedRef::javaobject> result)
     [](
       jsi::Runtime &rt,
       jsi::Function &jsFunction,
-      jni::global_ref<SharedRef::javaobject> arg,
-      bool isRejectCallback
+      jni::global_ref<SharedRef::javaobject> arg
     ) {
       const auto jsiContext = getJSIContext(rt);
       auto native = jni::make_local(arg);
@@ -248,4 +274,54 @@ void JavaCallback::invokeSharedRef(jni::alias_ref<SharedRef::javaobject> result)
     jni::make_global(result)
   );
 }
+
+void JavaCallback::invokeError(jni::alias_ref<jstring> code, jni::alias_ref<jstring> errorMessage) {
+  const auto strongCallbackContext = this->callbackContext.lock();
+  // The context were deallocated before the callback was invoked.
+  if (strongCallbackContext == nullptr) {
+    return;
+  }
+
+  const auto jsInvoker = strongCallbackContext->jsCallInvokerHolder.lock();
+  // Call invoker is already released, so we cannot invoke the callback.
+  if (jsInvoker == nullptr) {
+    return;
+  }
+
+  jsInvoker->invokeAsync(
+    [
+      context = callbackContext,
+      code = code->toStdString(),
+      errorMessage = errorMessage->toStdString()
+    ]() -> void {
+      auto strongContext = context.lock();
+      // The context were deallocated before the callback was invoked.
+      if (strongContext == nullptr) {
+        return;
+      }
+
+      if (!strongContext->rejectHolder.has_value()) {
+        throw std::runtime_error(
+          "JavaCallback was already settled. Cannot invoke it again"
+        );
+      }
+
+      jsi::Function &jsFunction = strongContext->rejectHolder.value();
+      jsi::Runtime &rt = strongContext->rt;
+
+      auto codedError = makeCodedError(
+        rt,
+        jsi::String::createFromUtf8(rt, code),
+        jsi::String::createFromUtf8(rt, errorMessage)
+      );
+
+      jsFunction.call(
+        rt,
+        (const jsi::Value *) &codedError,
+        (size_t) 1
+      );
+
+      strongContext->invalidate();
+    });
+}
 } // namespace expo

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

@@ -13,6 +13,7 @@
 #include <react/jni/WritableNativeMap.h>
 #include <fbjni/detail/CoreClasses.h>
 #include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/LongLivedObject.h>
 
 namespace jni = facebook::jni;
 namespace react = facebook::react;
@@ -26,19 +27,27 @@ struct SharedRef : public jni::JavaClass<SharedRef> {
 
 class JSIContext;
 
-typedef std::variant<folly::dynamic, jni::global_ref<SharedRef::javaobject>> CallbackArg;
-
 class JavaCallback : public jni::HybridClass<JavaCallback, Destructible> {
 public:
   static auto constexpr
     kJavaDescriptor = "Lexpo/modules/kotlin/jni/JavaCallback;";
   static auto constexpr TAG = "JavaCallback";
 
-  struct CallbackContext {
+  class CallbackContext : public react::LongLivedObject {
+  public:
+    CallbackContext(
+      jsi::Runtime &rt,
+      std::weak_ptr<react::CallInvoker> jsCallInvokerHolder,
+      std::optional<jsi::Function> resolveHolder,
+      std::optional<jsi::Function> rejectHolder
+    );
+
     jsi::Runtime &rt;
-    std::shared_ptr<react::CallInvoker> jsCallInvokerHolder;
-    std::optional<jsi::Function> jsFunctionHolder;
-    bool isRejectCallback;
+    std::weak_ptr<react::CallInvoker> jsCallInvokerHolder;
+    std::optional<jsi::Function> resolveHolder;
+    std::optional<jsi::Function> rejectHolder;
+
+    void invalidate();
   };
 
   static void registerNatives();
@@ -49,7 +58,7 @@ public:
   );
 
 private:
-  std::shared_ptr<CallbackContext> callbackContext;
+  std::weak_ptr<CallbackContext> callbackContext;
 
   friend HybridBase;
 
@@ -73,13 +82,10 @@ private:
 
   void invokeSharedRef(jni::alias_ref<SharedRef::javaobject> result);
 
+  void invokeError(jni::alias_ref<jstring> code, jni::alias_ref<jstring> errorMessage);
+
   template<class T>
-  using ArgsConverter = std::function<void(
-    jsi::Runtime &rt,
-    jsi::Function &jsFunction,
-    T arg,
-    bool isRejectCallback
-  )>;
+  using ArgsConverter = std::function<void(jsi::Runtime &rt, jsi::Function &jsFunction, T arg)>;
 
   template<class T>
   inline void invokeJSFunction(

package/android/src/main/cpp/JavaReferencesCache.cpp

@@ -36,7 +36,7 @@ void JavaReferencesCache::loadJClasses(JNIEnv *env) {
   });
 
   loadJClass(env, "expo/modules/kotlin/jni/PromiseImpl", {
-    {"<init>", "(Lexpo/modules/kotlin/jni/JavaCallback;Lexpo/modules/kotlin/jni/JavaCallback;)V"}
+    {"<init>", "(Lexpo/modules/kotlin/jni/JavaCallback;)V"}
   });
 
   loadJClass(env, "java/lang/Object", {});

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

@@ -7,13 +7,14 @@
 #include "Exceptions.h"
 #include "JavaCallback.h"
 #include "types/JNIToJSIConverter.h"
+#include "JSReferencesCache.h"
 
 #include <utility>
 #include <functional>
 #include <unistd.h>
 #include <optional>
 
-#include "JSReferencesCache.h"
+#include <ReactCommon/LongLivedObject.h>
 
 namespace jni = facebook::jni;
 namespace jsi = facebook::jsi;
@@ -21,10 +22,10 @@ namespace react = facebook::react;
 
 namespace expo {
 
-jni::local_ref<JavaCallback::JavaPart> createJavaCallbackFromJSIFunction(
-  jsi::Function &&function,
-  jsi::Runtime &rt,
-  bool isRejectCallback = false
+jni::local_ref<JavaCallback::JavaPart> createJavaCallback(
+  jsi::Function &&resolveFunction,
+  jsi::Function &&rejectFunction,
+  jsi::Runtime &rt
 ) {
   JSIContext *jsiContext = getJSIContext(rt);
   std::shared_ptr<react::CallInvoker> jsInvoker = jsiContext->runtimeHolder->jsInvoker;
@@ -32,10 +33,16 @@ jni::local_ref<JavaCallback::JavaPart> createJavaCallbackFromJSIFunction(
   std::shared_ptr<JavaCallback::CallbackContext> callbackContext = std::make_shared<JavaCallback::CallbackContext>(
     rt,
     std::move(jsInvoker),
-    std::move(function),
-    isRejectCallback
+    std::move(resolveFunction),
+    std::move(rejectFunction)
   );
 
+#if REACT_NATIVE_TARGET_VERSION >= 75
+  facebook::react::LongLivedObjectCollection::get(rt).add(callbackContext);
+#else
+  facebook::react::LongLivedObjectCollection::get().add(callbackContext);
+#endif
+
   return JavaCallback::newInstance(jsiContext, std::move(callbackContext));
 }
 
@@ -336,15 +343,10 @@ jsi::Function MethodMetadata::createPromiseBody(
       jsi::Function resolveJSIFn = promiseConstructorArgs[0].getObject(rt).getFunction(rt);
       jsi::Function rejectJSIFn = promiseConstructorArgs[1].getObject(rt).getFunction(rt);
 
-      jobject resolve = createJavaCallbackFromJSIFunction(
+      jobject javaCallback = createJavaCallback(
         std::move(resolveJSIFn),
-        rt
-      ).release();
-
-      jobject reject = createJavaCallbackFromJSIFunction(
         std::move(rejectJSIFn),
-        rt,
-        true
+        rt
       ).release();
 
       JNIEnv *env = jni::Environment::current();
@@ -353,15 +355,14 @@ jsi::Function MethodMetadata::createPromiseBody(
         "expo/modules/kotlin/jni/PromiseImpl");
       jmethodID jPromiseConstructor = jPromise.getMethod(
         "<init>",
-        "(Lexpo/modules/kotlin/jni/JavaCallback;Lexpo/modules/kotlin/jni/JavaCallback;)V"
+        "(Lexpo/modules/kotlin/jni/JavaCallback;)V"
       );
 
       // Creates a promise object
       jobject promise = env->NewObject(
         jPromise.clazz,
         jPromiseConstructor,
-        resolve,
-        reject
+        javaCallback
       );
 
       // Cast in this place is safe, cause we know that this function expects promise.

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

@@ -33,7 +33,7 @@ interface Promise {
 fun Promise.toBridgePromise(): com.facebook.react.bridge.Promise {
   val expoPromise = this
   val resolveMethod: (value: Any?) -> Unit = if (expoPromise is PromiseImpl) {
-    expoPromise.resolveBlock::invoke
+    expoPromise.callback::invoke
   } else {
     expoPromise::resolve
   }

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

@@ -6,6 +6,11 @@ import android.util.Log
 import okhttp3.Interceptor
 import okhttp3.Request
 import okhttp3.Response
+import okhttp3.ResponseBody
+import okhttp3.ResponseBody.Companion.asResponseBody
+import okio.GzipSource
+import okio.buffer
+import java.io.IOException
 
 private const val TAG = "ExpoNetworkInspector"
 
@@ -31,7 +36,9 @@ class ExpoNetworkInspectOkHttpNetworkInterceptor : Interceptor {
           it.priorResponse = response
         }
       } else {
-        delegate.didReceiveResponse(requestId, request, response)
+        val body = peekResponseBody(response)
+        delegate.didReceiveResponse(requestId, request, response, body)
+        body?.close()
       }
     } catch (e: Exception) {
       Log.e(TAG, "Failed to send network request CDP event", e)
@@ -62,9 +69,18 @@ class ExpoNetworkInspectOkHttpAppInterceptor : Interceptor {
  * The delegate to dispatch network request events
  */
 internal interface ExpoNetworkInspectOkHttpInterceptorsDelegate {
-  fun willSendRequest(requestId: String, request: Request, redirectResponse: Response?)
+  fun willSendRequest(
+    requestId: String,
+    request: Request,
+    redirectResponse: Response?
+  )
 
-  fun didReceiveResponse(requestId: String, request: Request, response: Response)
+  fun didReceiveResponse(
+    requestId: String,
+    request: Request,
+    response: Response,
+    body: ResponseBody?
+  )
 }
 
 /**
@@ -74,3 +90,36 @@ internal class RedirectResponse {
   var requestId: String? = null
   var priorResponse: Response? = null
 }
+
+/**
+ * Peek response body that could send to CDP delegate.
+ * Also uncompress gzip payload if necessary since OkHttp [Interceptor] does not uncompress payload for you.
+ * @return null if the response body exceeds [byteCount]
+ */
+internal fun peekResponseBody(
+  response: Response,
+  byteCount: Long = ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE
+): ResponseBody? {
+  val body = response.body ?: return null
+  val peeked = body.source().peek()
+  try {
+    if (peeked.request(byteCount + 1)) {
+      // When the request() returns true,
+      // it means the source have more available bytes then [byteCount].
+      return null
+    }
+  } catch (_: IOException) {}
+
+  val encoding = response.header("Content-Encoding")
+  val source = when {
+    encoding.equals("gzip", ignoreCase = true) ->
+      GzipSource(peeked).buffer().apply {
+        request(byteCount)
+      }
+    else -> peeked
+  }
+
+  val buffer = okio.Buffer()
+  buffer.write(source, minOf(byteCount, source.buffer.size))
+  return buffer.asResponseBody(body.contentType(), buffer.size)
+}

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

@@ -13,6 +13,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import okhttp3.Request
 import okhttp3.Response
+import okhttp3.ResponseBody
 import java.math.BigDecimal
 import java.math.RoundingMode
 
@@ -38,7 +39,11 @@ object ExpoRequestCdpInterceptor : ExpoNetworkInspectOkHttpInterceptorsDelegate
 
   //region ExpoNetworkInspectOkHttpInterceptorsDelegate implementations
 
-  override fun willSendRequest(requestId: String, request: Request, redirectResponse: Response?) {
+  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)
@@ -48,14 +53,19 @@ object ExpoRequestCdpInterceptor : ExpoNetworkInspectOkHttpInterceptorsDelegate
     dispatchEvent(Event("Network.requestWillBeSentExtraInfo", params2))
   }
 
-  override fun didReceiveResponse(requestId: String, request: Request, response: Response) {
+  override fun didReceiveResponse(
+    requestId: String,
+    request: Request,
+    response: Response,
+    body: ResponseBody?
+  ) {
     val now = BigDecimal(System.currentTimeMillis() / 1000.0).setScale(3, RoundingMode.CEILING)
 
     val params = ResponseReceivedParams(now, requestId, request, response)
     dispatchEvent(Event("Network.responseReceived", params))
 
-    if (response.peekBody(ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE + 1).contentLength() <= ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE) {
-      val params2 = ExpoReceivedResponseBodyParams(now, requestId, request, response)
+    if (body != null) {
+      val params2 = ExpoReceivedResponseBodyParams(now, requestId, request, response, body)
       dispatchEvent(Event("Expo(Network.receivedResponseBody)", params2))
     }
 

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

@@ -227,15 +227,20 @@ data class ExpoReceivedResponseBodyParams(
   var body: String,
   var base64Encoded: Boolean
 ) : JsonSerializable {
-  constructor(now: BigDecimal, requestId: RequestId, request: okhttp3.Request, response: okhttp3.Response) : this(
+  constructor(
+    now: BigDecimal,
+    requestId: RequestId,
+    request: okhttp3.Request,
+    response: okhttp3.Response,
+    body: okhttp3.ResponseBody
+  ) : this(
     requestId = requestId,
     body = "",
     base64Encoded = false
   ) {
-    val rawBody = response.peekBody(ExpoNetworkInspectOkHttpNetworkInterceptor.MAX_BODY_SIZE)
-    val contentType = rawBody.contentType()
+    val contentType = body.contentType()
     val isText = contentType?.type == "text" || (contentType?.type == "application" && contentType.subtype == "json")
-    val bodyString = if (isText) rawBody.string() else rawBody.source().readByteString().base64()
+    val bodyString = if (isText) body.string() else body.source().readByteString().base64()
 
     this.body = bodyString
     this.base64Encoded = !isText

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

@@ -49,6 +49,10 @@ class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHyb
     invokeNative(result)
   }
 
+  operator fun invoke(code: String, errorMessage: String) = checkIfValid {
+    invokeNative(code, errorMessage)
+  }
+
   private external fun invokeNative()
   private external fun invokeNative(result: Int)
   private external fun invokeNative(result: Boolean)
@@ -58,6 +62,7 @@ class JavaCallback @DoNotStrip internal constructor(@DoNotStrip private val mHyb
   private external fun invokeNative(result: WritableNativeArray)
   private external fun invokeNative(result: WritableNativeMap)
   private external fun invokeNative(result: SharedRef<*>)
+  private external fun invokeNative(code: String, errorMessage: String)
 
   private inline fun checkIfValid(body: () -> Unit) {
     try {

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

@@ -1,8 +1,5 @@
 package expo.modules.kotlin.jni
 
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeArray
-import com.facebook.react.bridge.WritableNativeMap
 import expo.modules.BuildConfig
 import expo.modules.core.interfaces.DoNotStrip
 import expo.modules.kotlin.AppContext
@@ -30,8 +27,7 @@ private const val STACK_FRAME_KEY_METHOD_NAME = "methodName"
 
 @DoNotStrip
 class PromiseImpl @DoNotStrip internal constructor(
-  @DoNotStrip internal val resolveBlock: JavaCallback,
-  @DoNotStrip internal val rejectBlock: JavaCallback
+  @DoNotStrip internal val callback: JavaCallback
 ) : Promise {
   internal var wasSettled = false
     private set
@@ -39,80 +35,35 @@ class PromiseImpl @DoNotStrip internal constructor(
   private var fullFunctionName: String? = null
 
   override fun resolve(value: Any?) = checkIfWasSettled {
-    resolveBlock(
+    callback.invoke(
       JSTypeConverter.convertToJSValue(value)
     )
   }
 
   override fun resolve(result: Int) = checkIfWasSettled {
-    resolveBlock.invoke(result)
+    callback.invoke(result)
   }
 
   override fun resolve(result: Boolean) = checkIfWasSettled {
-    resolveBlock.invoke(result)
+    callback.invoke(result)
   }
 
   override fun resolve(result: Double) = checkIfWasSettled {
-    resolveBlock.invoke(result)
+    callback.invoke(result)
   }
 
   override fun resolve(result: Float) = checkIfWasSettled {
-    resolveBlock.invoke(result)
+    callback.invoke(result)
   }
 
   override fun resolve(result: String) = checkIfWasSettled {
-    resolveBlock.invoke(result)
+    callback.invoke(result)
   }
 
   // Copy of the reject method from [com.facebook.react.bridge.PromiseImpl]
   override fun reject(code: String, message: String?, cause: Throwable?) = checkIfWasSettled {
-    val errorInfo = WritableNativeMap()
-
-    errorInfo.putString(ERROR_MAP_KEY_CODE, code)
-
-    // Use the custom message if provided otherwise use the throwable message.
-    if (message != null) {
-      errorInfo.putString(ERROR_MAP_KEY_MESSAGE, message)
-    } else if (cause != null) {
-      errorInfo.putString(ERROR_MAP_KEY_MESSAGE, cause.message)
-    } else {
-      // The JavaScript side expects a map with at least an error message.
-      // /Libraries/BatchedBridge/NativeModules.js -> createErrorFromErrorData
-      // TYPE: (errorData: { message: string })
-      errorInfo.putString(ERROR_MAP_KEY_MESSAGE, ERROR_DEFAULT_MESSAGE)
-    }
-
-    // For consistency with iOS ensure userInfo key exists, even if we null it.
-    // iOS: /React/Base/RCTUtils.m -> RCTJSErrorFromCodeMessageAndNSError
-    errorInfo.putNull(ERROR_MAP_KEY_USER_INFO)
-
-    // Attach a nativeStackAndroid array if a throwable was passed
-    // this matches iOS behavior - iOS adds a `nativeStackIOS` property
-    // iOS: /React/Base/RCTUtils.m -> RCTJSErrorFromCodeMessageAndNSError
-    if (cause != null) {
-      val stackTrace: Array<StackTraceElement> = cause.stackTrace
-      val nativeStackAndroid = WritableNativeArray()
-
-      // Build an an Array of StackFrames to match JavaScript:
-      // iOS: /Libraries/Core/Devtools/parseErrorStack.js -> StackFrame
-      var i = 0
-      while (i < stackTrace.size && i < ERROR_STACK_FRAME_LIMIT) {
-        val frame = stackTrace[i]
-        val frameMap: WritableMap = WritableNativeMap()
-        // NOTE: no column number exists StackTraceElement
-        frameMap.putString(STACK_FRAME_KEY_CLASS, frame.className)
-        frameMap.putString(STACK_FRAME_KEY_FILE, frame.fileName)
-        frameMap.putInt(STACK_FRAME_KEY_LINE_NUMBER, frame.lineNumber)
-        frameMap.putString(STACK_FRAME_KEY_METHOD_NAME, frame.methodName)
-        nativeStackAndroid.pushMap(frameMap)
-        i++
-      }
-      errorInfo.putArray(ERROR_MAP_KEY_NATIVE_STACK, nativeStackAndroid)
-    } else {
-      errorInfo.putArray(ERROR_MAP_KEY_NATIVE_STACK, WritableNativeArray())
-    }
-
-    rejectBlock.invoke(errorInfo)
+    // TODO(@lukmccall): Add information about the stack trace to the error message
+    callback.invoke(code, message ?: cause?.message ?: "unknown")
   }
 
   private inline fun checkIfWasSettled(body: () -> Unit) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "1.12.2",
+  "version": "1.12.4",
   "description": "The core of Expo Modules architecture",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -44,5 +44,5 @@
     "@testing-library/react-hooks": "^7.0.1",
     "expo-module-scripts": "^3.0.0"
   },
-  "gitHead": "ee4f30ef3b5fa567ad1bf94794197f7683fdd481"
+  "gitHead": "4a7cf0d0baf6dfc595d93f604945d2142e705a36"
 }