react-native-tvos 0.85.2-0 → 0.86.0-0rc2

package/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/rewrite_feature_flag_defaults.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env fbpython
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-strict
+
+"""Rewrite default return values in ReactNativeFeatureFlagsDefaults.kt.
+
+Reads the Kotlin source from --input, writes the transformed source to stdout.
+Overrides are passed as a JSON object via --overrides.
+Fails with a non-zero exit code if any requested flag is not found.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+
+
+def kotlin_literal(value: bool | int | float) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        s = str(value)
+        if isinstance(value, int) or "." not in s:
+            s += ".0"
+        return s
+    raise ValueError(f"Unsupported value type {type(value).__name__} for override")
+
+
+def rewrite(source: bytes, overrides: dict[str, object]) -> bytes:
+    text = source.decode("utf-8")
+    for name, value in overrides.items():
+        kotlin_type = "Boolean" if isinstance(value, bool) else "Double"
+        pattern = rf"""
+            (
+                override \s+ fun \s+
+                {re.escape(name)}
+                \s* \( \s* \)
+                \s* : \s* {kotlin_type}
+                \s* = \s*
+            )
+            \S+
+        """
+        text, n = re.subn(
+            pattern,
+            rf"\g<1>{kotlin_literal(value)}",
+            text,
+            count=1,
+            flags=re.VERBOSE,
+        )
+        if n != 1:
+            raise ValueError(f"{name} not matched")
+
+    return text.encode("utf-8")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--overrides", default="{}")
+    parser.add_argument("--input", required=True)
+    args = parser.parse_args()
+
+    overrides: dict[str, object] = json.loads(args.overrides)
+    with open(args.input, "rb") as f:
+        source = f.read()
+
+    sys.stdout.buffer.write(rewrite(source, overrides))
+
+
+if __name__ == "__main__":
+    main()

package/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/tests/test_rewrite_feature_flag_defaults.py

@@ -0,0 +1,63 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-strict
+
+from __future__ import annotations
+
+import os
+import unittest
+
+from rewrite_feature_flag_defaults import kotlin_literal, rewrite
+
+
+def _load_source() -> bytes:
+    with open(os.environ["SOURCE_PATH"], "rb") as f:
+        return f.read()
+
+
+class RewriteFeatureFlagDefaultsTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.source = _load_source()
+
+    def test_empty_overrides_is_passthrough(self) -> None:
+        self.assertEqual(rewrite(self.source, {}), self.source)
+
+    def test_override_bool_to_true(self) -> None:
+        result = rewrite(self.source, {"commonTestFlag": True})
+        self.assertEqual(self._method_value(result, "commonTestFlag"), b"true")
+
+    def test_override_bool_to_false(self) -> None:
+        result = rewrite(self.source, {"commonTestFlag": False})
+        self.assertEqual(self._method_value(result, "commonTestFlag"), b"false")
+
+    def test_kotlin_literal_int_produces_double(self) -> None:
+        self.assertEqual(kotlin_literal(42), "42.0")
+
+    def test_kotlin_literal_float(self) -> None:
+        self.assertEqual(kotlin_literal(3.14), "3.14")
+
+    def test_unmatched_flag_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            rewrite(self.source, {"bogusFlag": True})
+
+    def test_only_target_method_changes(self) -> None:
+        result = rewrite(self.source, {"commonTestFlag": True})
+        src_start, src_end = self._method_value_range(self.source, "commonTestFlag")
+        res_start, res_end = self._method_value_range(result, "commonTestFlag")
+        self.assertEqual(self.source[:src_start], result[:res_start])
+        self.assertEqual(self.source[src_end:], result[res_end:])
+
+    def _method_value_range(self, source: bytes, name: str) -> tuple[int, int]:
+        name_idx = source.find(name.encode())
+        self.assertNotEqual(name_idx, -1, f"{name} not found in output")
+        eq_idx = source.find(b"=", name_idx)
+        eol_idx = source.find(b"\n", eq_idx)
+        start = eq_idx + 2  # skip "= "
+        return (start, eol_idx)
+
+    def _method_value(self, source: bytes, name: str) -> bytes:
+        start, end = self._method_value_range(source, name)
+        return source[start:end].strip()

package/ReactAndroid/src/main/java/com/facebook/react/internal/tracing/PerformanceTracer.kt

@@ -20,7 +20,46 @@ import com.facebook.soloader.SoLoader
 @DoNotStrip
 public object PerformanceTracer {
   init {
-    SoLoader.loadLibrary("react_performancetracerjni")
+    SoLoader.loadLibrary("react_tracingjni")
+  }
+
+  public fun <T> trace(name: String, block: () -> T): T {
+    return trace(name, null /* track */, null /* trackGroup */, null /* color */, block)
+  }
+
+  public fun <T> trace(name: String, track: String, block: () -> T): T {
+    return trace(name, track, null /* trackGroup */, null /* color */, block)
+  }
+
+  public fun <T> trace(name: String, track: String, trackGroup: String, block: () -> T): T {
+    return trace(name, track, trackGroup, null /* color */, block)
+  }
+
+  public fun <T> trace(
+      name: String,
+      track: String?,
+      trackGroup: String?,
+      color: String?,
+      block: () -> T,
+  ): T {
+    if (!isTracing()) {
+      return block()
+    }
+
+    val startTimeNanos = java.lang.System.nanoTime()
+    try {
+      return block()
+    } finally {
+      val endTimeNanos = java.lang.System.nanoTime()
+      reportTimeStamp(
+          name,
+          startTimeNanos,
+          endTimeNanos,
+          track,
+          trackGroup,
+          color,
+      )
+    }
   }
 
   /** Callback interface for tracing state changes. */

package/ReactAndroid/src/main/java/com/facebook/react/modules/appearance/AppearanceModule.kt

@@ -137,6 +137,9 @@ constructor(
     public const val NAME: String = NativeAppearanceSpec.NAME
     private const val APPEARANCE_CHANGED_EVENT_NAME = "appearanceChanged"
 
+    // Must remain `var` (not `val`) — this field is set from JNI in
+    // configurePlatformColorCacheInvalidationHook.cpp. Android 17+ crashes
+    // if JNI modifies a static final field (which `val` compiles to).
     @DoNotStrip private var invalidatePlatformColorCache: Runnable? = null
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/blob/BlobModule.kt

@@ -23,6 +23,9 @@ import com.facebook.react.bridge.buildReadableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.network.NetworkingModule
 import com.facebook.react.modules.websocket.WebSocketModule
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
+import com.facebook.soloader.SoLoader
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileNotFoundException
@@ -39,7 +42,7 @@ import okio.ByteString
 
 @ReactModule(name = NativeBlobModuleSpec.NAME)
 public class BlobModule(reactContext: ReactApplicationContext) :
-    NativeBlobModuleSpec(reactContext) {
+    NativeBlobModuleSpec(reactContext), TurboModuleWithJSIBindings {
 
   private val blobs = HashMap<String, ByteArray>()
 
@@ -128,10 +131,6 @@ public class BlobModule(reactContext: ReactApplicationContext) :
         }
       }
 
-  public override fun initialize() {
-    BlobCollector.install(reactApplicationContext, this)
-  }
-
   public override fun getTypedExportedConstants(): Map<String, Any> {
     val resources = reactApplicationContext.resources
     val packageName = reactApplicationContext.packageName
@@ -331,7 +330,13 @@ public class BlobModule(reactContext: ReactApplicationContext) :
     remove(blobId)
   }
 
+  @DoNotStrip external override fun getBindingsInstaller(): BindingsInstallerHolder
+
   public companion object {
+    init {
+      SoLoader.loadLibrary("reactnativeblob")
+    }
+
     public const val NAME: String = NativeBlobModuleSpec.NAME
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/blob/BlobProvider.kt

@@ -53,9 +53,8 @@ public class BlobProvider : ContentProvider() {
     var blobModule: BlobModule? = null
     val context = context?.applicationContext
     if (context is ReactApplication) {
-      @Suppress("DEPRECATION") val host = (context as ReactApplication).reactNativeHost
       val reactContext =
-          host.reactInstanceManager.currentReactContext
+          context.reactHost?.currentReactContext
               ?: throw RuntimeException("No ReactContext associated with BlobProvider")
       blobModule = reactContext.getNativeModule(BlobModule::class.java)
     }

package/ReactAndroid/src/main/java/com/facebook/react/modules/clipboard/ClipboardModule.kt

@@ -7,6 +7,7 @@
 
 package com.facebook.react.modules.clipboard
 
+import android.annotation.SuppressLint
 import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
@@ -22,6 +23,7 @@ internal class ClipboardModule(context: ReactApplicationContext) : NativeClipboa
   private val clipboardService: ClipboardManager
     get() = reactApplicationContext.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
 
+  @SuppressLint("ClipboardUsage")
   override fun getString(promise: Promise) {
     try {
       val clipboard = clipboardService
@@ -37,6 +39,7 @@ internal class ClipboardModule(context: ReactApplicationContext) : NativeClipboa
     }
   }
 
+  @SuppressLint("ClipboardUsage")
   override fun setString(text: String?) {
     val clipdata: ClipData = ClipData.newPlainText(null, text)
     clipboardService.setPrimaryClip(clipdata)

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/DeviceEventManagerModule.kt

@@ -36,7 +36,8 @@ public open class DeviceEventManagerModule(
   public open fun emitHardwareBackPressed() {
     val reactApplicationContext: ReactApplicationContext? =
         getReactApplicationContextIfActiveOrWarn()
-    reactApplicationContext?.emitDeviceEvent("hardwareBackPress", null)
+    val map = buildReadableMap { put("timeStamp", System.nanoTime() / 1_000_000.0) }
+    reactApplicationContext?.emitDeviceEvent("hardwareBackPress", map)
   }
 
   /** Sends an event to the JS instance that a new intent was received. */

package/ReactAndroid/src/main/java/com/facebook/react/modules/core/ReactChoreographer.kt

@@ -44,28 +44,27 @@ public class ReactChoreographer private constructor(choreographerProvider: Chore
   private var totalCallbacks = 0
   @GuardedBy("callbackQueues") private var hasPostedCallback = false
 
-  private val frameCallback =
-      Choreographer.FrameCallback { frameTimeNanos ->
-        synchronized(callbackQueues) {
-          // Callbacks run once and are then automatically removed, the callback will
-          // be posted again from postFrameCallback
-          hasPostedCallback = false
-          for (i in callbackQueues.indices) {
-            val callbackQueue = callbackQueues[i]
-            val initialLength = callbackQueue.size
-            for (callback in 0 until initialLength) {
-              val frameCallback = callbackQueue.pollFirst()
-              if (frameCallback != null) {
-                frameCallback.doFrame(frameTimeNanos)
-                totalCallbacks--
-              } else {
-                FLog.e(ReactConstants.TAG, "Tried to execute non-existent frame callback")
-              }
-            }
+  private val frameCallback = Choreographer.FrameCallback { frameTimeNanos ->
+    synchronized(callbackQueues) {
+      // Callbacks run once and are then automatically removed, the callback will
+      // be posted again from postFrameCallback
+      hasPostedCallback = false
+      for (i in callbackQueues.indices) {
+        val callbackQueue = callbackQueues[i]
+        val initialLength = callbackQueue.size
+        for (callback in 0 until initialLength) {
+          val frameCallback = callbackQueue.pollFirst()
+          if (frameCallback != null) {
+            frameCallback.doFrame(frameTimeNanos)
+            totalCallbacks--
+          } else {
+            FLog.e(ReactConstants.TAG, "Tried to execute non-existent frame callback")
           }
-          maybeRemoveFrameCallback()
         }
       }
+      maybeRemoveFrameCallback()
+    }
+  }
 
   init {
     UiThreadUtil.runOnUiThread { choreographer = choreographerProvider.getChoreographer() }
@@ -138,6 +137,8 @@ public class ReactChoreographer private constructor(choreographerProvider: Chore
 
     @VisibleForTesting
     internal fun overrideInstanceForTest(instance: ReactChoreographer?): ReactChoreographer? =
-        choreographer.also { choreographer = instance }
+        choreographer.also {
+          choreographer = instance
+        }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/deviceinfo/DeviceInfoModule.kt

@@ -7,14 +7,21 @@
 
 package com.facebook.react.modules.deviceinfo
 
+import android.util.DisplayMetrics
+import androidx.annotation.VisibleForTesting
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.window.layout.WindowMetricsCalculator
 import com.facebook.fbreact.specs.NativeDeviceInfoSpec
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactNoCrashSoftException
 import com.facebook.react.bridge.ReactSoftExceptionLogger
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.DisplayMetricsHolder.getDisplayMetricsWritableMap
+import com.facebook.react.uimanager.DisplayMetricsHolder.getScreenDisplayMetrics
 import com.facebook.react.uimanager.DisplayMetricsHolder.initDisplayMetricsIfNotInitialized
 import com.facebook.react.views.view.isEdgeToEdgeFeatureFlagOn
 
@@ -30,8 +37,61 @@ internal class DeviceInfoModule(reactContext: ReactApplicationContext) :
     reactContext.addLifecycleEventListener(this)
   }
 
+  @VisibleForTesting
+  internal fun getWindowDisplayMetrics(): DisplayMetrics {
+    val windowDisplayMetrics = DisplayMetrics()
+    windowDisplayMetrics.setTo(reactApplicationContext.resources.displayMetrics)
+
+    val activity = reactApplicationContext.currentActivity ?: return windowDisplayMetrics
+    val bounds = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity).bounds
+
+    if (isEdgeToEdgeFeatureFlagOn) {
+      windowDisplayMetrics.widthPixels = bounds.width()
+      windowDisplayMetrics.heightPixels = bounds.height()
+    } else {
+      // WindowMetrics bounds include system bars. When edge-to-edge is not enabled, we subtract
+      // them so that window dimensions reflect the usable content area. If insets aren't yet
+      // available (e.g. before the first layout pass), fall back to resources.displayMetrics,
+      // which already excludes system bars in non-edge-to-edge mode.
+      ViewCompat.getRootWindowInsets(activity.window.decorView)?.let {
+        val insets =
+            it.getInsets(
+                WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()
+            )
+        windowDisplayMetrics.widthPixels = bounds.width() - (insets.left + insets.right)
+        windowDisplayMetrics.heightPixels = bounds.height() - (insets.top + insets.bottom)
+      }
+    }
+
+    return windowDisplayMetrics
+  }
+
+  @VisibleForTesting
+  internal fun getDisplayMetricsWritableMap(): WritableMap =
+      WritableNativeMap().apply {
+        putMap(
+            "windowPhysicalPixels",
+            getPhysicalPixelsWritableMap(getWindowDisplayMetrics()),
+        )
+        putMap(
+            "screenPhysicalPixels",
+            getPhysicalPixelsWritableMap(getScreenDisplayMetrics()),
+        )
+      }
+
+  private fun getPhysicalPixelsWritableMap(
+      displayMetrics: DisplayMetrics,
+  ): WritableMap =
+      WritableNativeMap().apply {
+        putInt("width", displayMetrics.widthPixels)
+        putInt("height", displayMetrics.heightPixels)
+        putDouble("scale", displayMetrics.density.toDouble())
+        putDouble("fontScale", fontScale.toDouble())
+        putDouble("densityDpi", displayMetrics.densityDpi.toDouble())
+      }
+
   public override fun getTypedExportedConstants(): Map<String, Any> {
-    val displayMetrics = getDisplayMetricsWritableMap(fontScale.toDouble())
+    val displayMetrics = getDisplayMetricsWritableMap()
 
     // Cache the initial dimensions for later comparison in emitUpdateDimensionsEvent
     previousDisplayMetrics = displayMetrics.copy()
@@ -58,7 +118,7 @@ internal class DeviceInfoModule(reactContext: ReactApplicationContext) :
     reactApplicationContext.let { context ->
       if (context.hasActiveReactInstance()) {
         // Don't emit an event to JS if the dimensions haven't changed
-        val displayMetrics = getDisplayMetricsWritableMap(fontScale.toDouble())
+        val displayMetrics = getDisplayMetricsWritableMap()
         if (previousDisplayMetrics == null) {
           previousDisplayMetrics = displayMetrics.copy()
         } else if (displayMetrics != previousDisplayMetrics) {

package/ReactAndroid/src/main/java/com/facebook/react/modules/image/ImageLoaderModule.kt

@@ -7,17 +7,20 @@
 
 package com.facebook.react.modules.image
 
+import android.media.ExifInterface
 import android.net.Uri
 import android.util.SparseArray
 import com.facebook.common.executors.CallerThreadExecutor
+import com.facebook.common.memory.PooledByteBuffer
 import com.facebook.common.references.CloseableReference
 import com.facebook.datasource.BaseDataSubscriber
 import com.facebook.datasource.DataSource
 import com.facebook.datasource.DataSubscriber
 import com.facebook.drawee.backends.pipeline.Fresco
 import com.facebook.fbreact.specs.NativeImageLoaderAndroidSpec
+import com.facebook.imagepipeline.common.RotationOptions
 import com.facebook.imagepipeline.core.ImagePipeline
-import com.facebook.imagepipeline.image.CloseableImage
+import com.facebook.imagepipeline.image.EncodedImage
 import com.facebook.imagepipeline.request.ImageRequest
 import com.facebook.imagepipeline.request.ImageRequestBuilder
 import com.facebook.react.bridge.GuardedAsyncTask
@@ -82,39 +85,13 @@ internal class ImageLoaderModule : NativeImageLoaderAndroidSpec, LifecycleEventL
       return
     }
     val source = ImageSource(reactApplicationContext, uriString)
-    val request: ImageRequest = ImageRequestBuilder.newBuilderWithSource(source.uri).build()
-    val dataSource: DataSource<CloseableReference<CloseableImage>> =
-        this.imagePipeline.fetchDecodedImage(request, this.callerContext)
-    val dataSubscriber: DataSubscriber<CloseableReference<CloseableImage>> =
-        object : BaseDataSubscriber<CloseableReference<CloseableImage>>() {
-          override fun onNewResultImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            if (!dataSource.isFinished) {
-              return
-            }
-            val ref = dataSource.result
-            if (ref != null) {
-              try {
-                val image: CloseableImage = ref.get()
-                val sizes = buildReadableMap {
-                  put("width", image.width)
-                  put("height", image.height)
-                }
-                promise.resolve(sizes)
-              } catch (e: Exception) {
-                promise.reject(ERROR_GET_SIZE_FAILURE, e)
-              } finally {
-                CloseableReference.closeSafely(ref)
-              }
-            } else {
-              promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
-            }
-          }
-
-          override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            promise.reject(ERROR_GET_SIZE_FAILURE, dataSource.failureCause)
-          }
-        }
-    dataSource.subscribe(dataSubscriber, CallerThreadExecutor.getInstance())
+    val request: ImageRequest =
+        ImageRequestBuilder.newBuilderWithSource(source.uri)
+            .setRotationOptions(RotationOptions.disableRotation())
+            .build()
+    val dataSource: DataSource<CloseableReference<PooledByteBuffer>> =
+        this.imagePipeline.fetchEncodedImage(request, this.callerContext)
+    dataSource.subscribe(createSizeSubscriber(promise), CallerThreadExecutor.getInstance())
   }
 
   /**
@@ -134,41 +111,61 @@ internal class ImageLoaderModule : NativeImageLoaderAndroidSpec, LifecycleEventL
     val source = ImageSource(reactApplicationContext, uriString)
     val imageRequestBuilder: ImageRequestBuilder =
         ImageRequestBuilder.newBuilderWithSource(source.uri)
+            .setRotationOptions(RotationOptions.disableRotation())
     val request: ImageRequest =
         ReactNetworkImageRequest.fromBuilderWithHeaders(imageRequestBuilder, headers)
-    val dataSource: DataSource<CloseableReference<CloseableImage>> =
-        this.imagePipeline.fetchDecodedImage(request, this.callerContext)
-    val dataSubscriber: DataSubscriber<CloseableReference<CloseableImage>> =
-        object : BaseDataSubscriber<CloseableReference<CloseableImage>>() {
-          override fun onNewResultImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            if (!dataSource.isFinished) {
-              return
-            }
-            val ref = dataSource.result
-            if (ref != null) {
-              try {
-                val image: CloseableImage = ref.get()
-                val sizes = buildReadableMap {
-                  put("width", image.width)
-                  put("height", image.height)
-                }
-                promise.resolve(sizes)
-              } catch (e: Exception) {
-                promise.reject(ERROR_GET_SIZE_FAILURE, e)
-              } finally {
-                CloseableReference.closeSafely(ref)
+    val dataSource: DataSource<CloseableReference<PooledByteBuffer>> =
+        this.imagePipeline.fetchEncodedImage(request, this.callerContext)
+    dataSource.subscribe(createSizeSubscriber(promise), CallerThreadExecutor.getInstance())
+  }
+
+  private fun createSizeSubscriber(
+      promise: Promise
+  ): DataSubscriber<CloseableReference<PooledByteBuffer>> =
+      object : BaseDataSubscriber<CloseableReference<PooledByteBuffer>>() {
+        override fun onNewResultImpl(dataSource: DataSource<CloseableReference<PooledByteBuffer>>) {
+          if (!dataSource.isFinished) {
+            return
+          }
+          val ref = dataSource.result
+          if (ref != null) {
+            var encodedImage: EncodedImage? = null
+            try {
+              encodedImage = EncodedImage(ref)
+              // Swap width and height when the image's EXIF orientation swaps the X/Y axes
+              // (90°/270° rotations, or transpose/transverse), so the values reflect the
+              // visible dimensions, matching iOS behavior.
+              val rotated =
+                  encodedImage.rotationAngle == 90 ||
+                      encodedImage.rotationAngle == 270 ||
+                      encodedImage.exifOrientation == ExifInterface.ORIENTATION_TRANSPOSE ||
+                      encodedImage.exifOrientation == ExifInterface.ORIENTATION_TRANSVERSE
+              val width = if (rotated) encodedImage.height else encodedImage.width
+              val height = if (rotated) encodedImage.width else encodedImage.height
+              if (width < 0 || height < 0) {
+                promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
+                return
+              }
+              val sizes = buildReadableMap {
+                put("width", width)
+                put("height", height)
               }
-            } else {
-              promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
+              promise.resolve(sizes)
+            } catch (e: Exception) {
+              promise.reject(ERROR_GET_SIZE_FAILURE, e)
+            } finally {
+              encodedImage?.close()
+              CloseableReference.closeSafely(ref)
             }
+          } else {
+            promise.reject(ERROR_GET_SIZE_FAILURE, "Failed to get the size of the image")
           }
+        }
 
-          override fun onFailureImpl(dataSource: DataSource<CloseableReference<CloseableImage>>) {
-            promise.reject(ERROR_GET_SIZE_FAILURE, dataSource.failureCause)
-          }
+        override fun onFailureImpl(dataSource: DataSource<CloseableReference<PooledByteBuffer>>) {
+          promise.reject(ERROR_GET_SIZE_FAILURE, dataSource.failureCause)
         }
-    dataSource.subscribe(dataSubscriber, CallerThreadExecutor.getInstance())
-  }
+      }
 
   /**
    * Prefetches the given image to the Fresco image disk cache.

package/ReactAndroid/src/main/java/com/facebook/react/modules/network/NetworkingModule.kt

@@ -773,6 +773,14 @@ public class NetworkingModule(
                       e.message,
                       e,
                   )
+                } catch (e: OutOfMemoryError) {
+                  NetworkEventUtil.onRequestError(
+                      reactApplicationContext,
+                      requestId,
+                      devToolsRequestId,
+                      "Out of memory while processing network response",
+                      null,
+                  )
                 }
               }
             }