react-native-tvos 0.86.2-0 → 0.87.0-0

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/MultipartStreamReader.kt

@@ -10,10 +10,14 @@
 package com.facebook.react.devsupport
 
 import java.io.IOException
+import java.util.TreeMap
 import kotlin.math.max
 import okio.Buffer
 import okio.BufferedSource
 import okio.ByteString
+import okio.Okio
+import okio.Source
+import okio.Timeout
 
 /** Utility class to parse the body of a response of type multipart/mixed. */
 internal class MultipartStreamReader(
@@ -25,7 +29,7 @@ internal class MultipartStreamReader(
   interface ChunkListener {
     /** Invoked when a chunk of a multipart response is fully downloaded. */
     @Throws(IOException::class)
-    fun onChunkComplete(headers: Map<String, String>, body: Buffer, isLastChunk: Boolean)
+    fun onChunkComplete(headers: Map<String, String>, body: BufferedSource, isLastChunk: Boolean)
 
     /** Invoked as bytes of the current chunk are read. */
     @Throws(IOException::class)
@@ -44,12 +48,16 @@ internal class MultipartStreamReader(
     val closeDelimiter: ByteString = ByteString.encodeUtf8("$CRLF--$boundary--$CRLF")
     val headersDelimiter: ByteString = ByteString.encodeUtf8(CRLF + CRLF)
 
-    val bufferLen = 4 * 1024
+    // Buffer size for reading from network. Increased from 4KB to 16KB for better I/O
+    // throughput and fewer syscalls. For a 2MB bundle: ~128 reads instead of ~512.
+    // Memory impact is negligible (12KB increase) while I/O overhead is significantly reduced.
+    val bufferLen = 16 * 1024
     var chunkStart: Long = 0
     var bytesSeen: Long = 0
     val content = Buffer()
+
     var currentHeaders: Map<String, String>? = null
-    var currentHeadersLength: Long = 0
+    var currentBodyStartIndexInContent: Long = -1
 
     while (true) {
       var isCloseDelimiter = false
@@ -58,6 +66,7 @@ internal class MultipartStreamReader(
       // to allow for the edge case when the delimiter is cut by read call.
       val searchStart =
           max((bytesSeen - closeDelimiter.size()).toDouble(), chunkStart.toDouble()).toLong()
+
       var indexOfDelimiter = content.indexOf(delimiter, searchStart)
       if (indexOfDelimiter == -1L) {
         isCloseDelimiter = true
@@ -68,16 +77,17 @@ internal class MultipartStreamReader(
         bytesSeen = content.size()
 
         if (currentHeaders == null) {
-          val indexOfHeaders = content.indexOf(headersDelimiter, searchStart)
-          if (indexOfHeaders >= 0) {
-            source.read(content, indexOfHeaders)
+          val indexOfHeadersDelimiter = content.indexOf(headersDelimiter, searchStart)
+          if (indexOfHeadersDelimiter >= 0) {
             val headers = Buffer()
-            content.copyTo(headers, searchStart, indexOfHeaders - searchStart)
-            currentHeadersLength = headers.size() + headersDelimiter.size()
+            content.copyTo(headers, searchStart, indexOfHeadersDelimiter - searchStart)
             currentHeaders = parseHeaders(headers)
+            currentBodyStartIndexInContent =
+                indexOfHeadersDelimiter + headersDelimiter.size().toLong()
           }
         } else {
-          emitProgress(currentHeaders, content.size() - currentHeadersLength, false, listener)
+          val loaded = max(0L, content.size() - currentBodyStartIndexInContent)
+          emitProgress(currentHeaders, loaded, false, listener)
         }
 
         val bytesRead = source.read(content, bufferLen.toLong())
@@ -92,26 +102,30 @@ internal class MultipartStreamReader(
 
       // Ignore preamble
       if (chunkStart > 0) {
-        val chunk = Buffer()
+        if (currentHeaders != null && currentBodyStartIndexInContent >= 0) {
+          val loadedFinal = max(0L, chunkEnd - currentBodyStartIndexInContent)
+          emitProgress(currentHeaders, loadedFinal, true, listener)
+        }
         content.skip(chunkStart)
-        content.read(chunk, length)
-        emitProgress(currentHeaders, chunk.size() - currentHeadersLength, true, listener)
-        emitChunk(chunk, isCloseDelimiter, listener)
+        emitChunk(content, length, isCloseDelimiter, listener)
+
         currentHeaders = null
-        currentHeadersLength = 0
+        currentBodyStartIndexInContent = -1
       } else {
         content.skip(chunkEnd)
       }
       if (isCloseDelimiter) {
         return true
       }
+
       chunkStart = delimiter.size().toLong()
       bytesSeen = chunkStart
     }
   }
 
   private fun parseHeaders(data: Buffer): Map<String, String> {
-    val headers: MutableMap<String, String> = mutableMapOf()
+    // Header names are case-insensitive
+    val headers: MutableMap<String, String> = TreeMap(String.CASE_INSENSITIVE_ORDER)
     val text = data.readUtf8()
     val lines = text.split(CRLF.toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
     for (line in lines) {
@@ -126,20 +140,81 @@ internal class MultipartStreamReader(
     return headers
   }
 
+  /**
+   * Emits a chunk to the listener. The `body` passed to the listener is bounded to the chunk body
+   * bytes, so the listener cannot accidentally read into the next boundary.
+   *
+   * Also drains any unread body bytes after the callback to keep parsing in sync.
+   */
   @Throws(IOException::class)
-  private fun emitChunk(chunk: Buffer, done: Boolean, listener: ChunkListener) {
+  private fun emitChunk(
+      content: Buffer,
+      chunkLength: Long,
+      done: Boolean,
+      listener: ChunkListener,
+  ) {
     val marker: ByteString = ByteString.encodeUtf8(CRLF + CRLF)
-    val indexOfMarker = chunk.indexOf(marker)
-    if (indexOfMarker == -1L) {
-      listener.onChunkComplete(emptyMap(), chunk, done)
-    } else {
-      val headers = Buffer()
-      val body = Buffer()
-      chunk.read(headers, indexOfMarker)
-      chunk.skip(marker.size().toLong())
-      chunk.readAll(body)
-      listener.onChunkComplete(parseHeaders(headers), body, done)
+    val indexOfMarker = content.indexOf(marker, 0)
+
+    if (indexOfMarker == -1L || indexOfMarker >= chunkLength) {
+      // No headers marker found inside the chunk. Treat the entire chunk as body.
+      val bodyLength = chunkLength
+      val body = Okio.buffer(FixedLengthSource(content, bodyLength))
+      try {
+        listener.onChunkComplete(emptyMap(), body, done)
+      } finally {
+        drainFully(body)
+      }
+      return
     }
+
+    // Headers exist.
+    val headersBuf = Buffer()
+    content.read(headersBuf, indexOfMarker)
+    content.skip(marker.size().toLong())
+    val headers = parseHeaders(headersBuf)
+
+    val maxBodyLength = chunkLength - indexOfMarker - marker.size().toLong()
+    val body = Okio.buffer(FixedLengthSource(content, maxBodyLength))
+    try {
+      listener.onChunkComplete(headers, body, done)
+    } finally {
+      drainFully(body)
+    }
+  }
+
+  private fun drainFully(body: BufferedSource) {
+    // Drain remaining bytes from this part body (if listener didn't).
+    // Use small reusable buffer to avoid unbounded memory.
+    val tmp = Buffer()
+    try {
+      while (true) {
+        val r = body.read(tmp, 8 * 1024L)
+        if (r == -1L) break
+        tmp.clear()
+      }
+    } catch (_: IOException) {
+      // Best-effort drain; parsing will likely fail upstream anyway.
+    }
+  }
+
+  private class FixedLengthSource(
+      private val upstream: Buffer,
+      private var remaining: Long,
+  ) : Source {
+    override fun read(sink: Buffer, byteCount: Long): Long {
+      if (byteCount == 0L) return 0L
+      if (remaining == 0L) return -1L
+      val toRead = minOf(byteCount, remaining)
+      val read = upstream.read(sink, toRead)
+      if (read == -1L) return -1L
+      remaining -= read
+      return read
+    }
+
+    override fun timeout(): Timeout = Timeout.NONE
+
+    override fun close() = Unit
   }
 
   @Throws(IOException::class)

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManager.java

@@ -93,6 +93,8 @@ import com.facebook.react.uimanager.events.SynchronousEventReceiver;
 import com.facebook.react.views.text.PreparedLayout;
 import com.facebook.react.views.text.ReactTextViewManager;
 import com.facebook.react.views.text.ReactTextViewManagerCallback;
+import com.facebook.react.views.text.ReactTypefaceUtils;
+import com.facebook.react.views.text.TextEffectRegistry;
 import com.facebook.react.views.text.TextLayoutManager;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -179,6 +181,8 @@ public class FabricUIManager
   private final MountItemDispatcher mMountItemDispatcher;
   private final ViewManagerRegistry mViewManagerRegistry;
 
+  private final TextEffectRegistry mTextEffectRegistry = new TextEffectRegistry();
+
   private final BatchEventDispatchedListener mBatchEventDispatchedListener;
 
   private final List<UIManagerListener> mListeners = new CopyOnWriteArrayList<>();
@@ -444,7 +448,8 @@ public class FabricUIManager
 
       ReactMarker.addFabricListener(mDevToolsReactPerfLogger);
     }
-    if (ReactNativeNewArchitectureFeatureFlags.useFabricInterop()) {
+    if (!ReactBuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP
+        && ReactNativeNewArchitectureFeatureFlags.useFabricInterop()) {
       InteropEventEmitter interopEventEmitter = new InteropEventEmitter(mReactApplicationContext);
       mReactApplicationContext.internal_registerInteropModule(
           RCTEventEmitter.class, interopEventEmitter);
@@ -511,7 +516,8 @@ public class FabricUIManager
    * [addUiBlock] and [prependUiBlock] on UIManagerModule.
    */
   public void addUIBlock(UIBlock block) {
-    if (ReactNativeNewArchitectureFeatureFlags.useFabricInterop()) {
+    if (!ReactBuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP
+        && ReactNativeNewArchitectureFeatureFlags.useFabricInterop()) {
       InteropUIBlockListener listener = getInteropUIBlockListener();
       listener.addUIBlock(block);
     }
@@ -522,7 +528,8 @@ public class FabricUIManager
    * [addUiBlock] and [prependUiBlock] on UIManagerModule.
    */
   public void prependUIBlock(UIBlock block) {
-    if (ReactNativeNewArchitectureFeatureFlags.useFabricInterop()) {
+    if (!ReactBuildConfig.UNSTABLE_REMOVE_LEGACY_COMPONENT_INTEROP
+        && ReactNativeNewArchitectureFeatureFlags.useFabricInterop()) {
       InteropUIBlockListener listener = getInteropUIBlockListener();
       listener.prependUIBlock(block);
     }
@@ -547,13 +554,15 @@ public class FabricUIManager
     return (NativeArray)
         TextLayoutManager.measureLines(
             mReactApplicationContext.getAssets(),
+            ReactTypefaceUtils.getFontWeightAdjustment(mReactApplicationContext),
             attributedString,
             paragraphAttributes,
             PixelUtil.toPixelFromDIP(width),
             PixelUtil.toPixelFromDIP(height),
             textViewManager instanceof ReactTextViewManagerCallback
                 ? (ReactTextViewManagerCallback) textViewManager
-                : null);
+                : null,
+            mTextEffectRegistry);
   }
 
   public int getColor(int surfaceId, String[] resourcePaths) {
@@ -632,6 +641,7 @@ public class FabricUIManager
 
     return TextLayoutManager.measureText(
         mReactApplicationContext.getAssets(),
+        ReactTypefaceUtils.getFontWeightAdjustment(mReactApplicationContext),
         attributedString,
         paragraphAttributes,
         getYogaSize(minWidth, maxWidth),
@@ -641,7 +651,8 @@ public class FabricUIManager
         textViewManager instanceof ReactTextViewManagerCallback
             ? (ReactTextViewManagerCallback) textViewManager
             : null,
-        attachmentsPositions);
+        attachmentsPositions,
+        mTextEffectRegistry);
   }
 
   @AnyThread
@@ -658,6 +669,7 @@ public class FabricUIManager
 
     return TextLayoutManager.createPreparedLayout(
         mReactApplicationContext.getAssets(),
+        ReactTypefaceUtils.getFontWeightAdjustment(mReactApplicationContext),
         attributedString,
         paragraphAttributes,
         getYogaSize(minWidth, maxWidth),
@@ -666,7 +678,8 @@ public class FabricUIManager
         getYogaMeasureMode(minHeight, maxHeight),
         textViewManager instanceof ReactTextViewManagerCallback
             ? (ReactTextViewManagerCallback) textViewManager
-            : null);
+            : null,
+        mTextEffectRegistry);
   }
 
   @AnyThread
@@ -700,6 +713,11 @@ public class FabricUIManager
         getYogaMeasureMode(minHeight, maxHeight));
   }
 
+  @UnstableReactNativeAPI
+  public TextEffectRegistry getTextEffectRegistry() {
+    return mTextEffectRegistry;
+  }
+
   /**
    * @param surfaceId {@link int} surface ID
    * @param defaultTextInputPadding {@link float[]} output parameter will contain the default theme
@@ -1199,42 +1217,22 @@ public class FabricUIManager
       return;
     }
 
-    EventEmitterWrapper eventEmitter = mMountingManager.getEventEmitter(surfaceId, reactTag);
-    if (eventEmitter == null) {
-      if (mMountingManager.getViewExists(reactTag)) {
-        // The view is pre-allocated and created. However, it hasn't been mounted yet. We will have
-        // access to the event emitter later when the view is mounted. For now just save the event
-        // in the view state and trigger it later.
-        mMountingManager.enqueuePendingEvent(
-            surfaceId,
-            reactTag,
-            eventName,
-            canCoalesceEvent,
-            params,
-            eventCategory,
-            eventTimestamp);
-      } else {
-        // This can happen if the view has disappeared from the screen (because of async events)
-        FLog.i(TAG, "Unable to invoke event: " + eventName + " for reactTag: " + reactTag);
-      }
-      return;
-    }
-
     if (experimentalIsSynchronous) {
       UiThreadUtil.assertOnUiThread();
-      // add() returns true only if there are no equivalent events already in the set
-      boolean firstEventForFrame =
-          mSynchronousEvents.add(new SynchronousEvent(surfaceId, reactTag, eventName));
-      if (firstEventForFrame) {
-        eventEmitter.dispatchEventSynchronously(eventName, params, eventTimestamp);
-      }
-    } else {
-      if (canCoalesceEvent) {
-        eventEmitter.dispatchUnique(eventName, params, eventTimestamp);
-      } else {
-        eventEmitter.dispatch(eventName, params, eventCategory, eventTimestamp);
+      EventEmitterWrapper eventEmitter = mMountingManager.getEventEmitter(surfaceId, reactTag);
+      if (eventEmitter != null) {
+        // add() returns true only if there are no equivalent events already in the set
+        boolean firstEventForFrame =
+            mSynchronousEvents.add(new SynchronousEvent(surfaceId, reactTag, eventName));
+        if (firstEventForFrame) {
+          eventEmitter.dispatchEventSynchronously(eventName, params, eventTimestamp);
+        }
+        return;
       }
     }
+
+    mMountingManager.dispatchEvent(
+        surfaceId, reactTag, eventName, canCoalesceEvent, params, eventCategory, eventTimestamp);
   }
 
   @Override
@@ -1630,6 +1628,10 @@ public class FabricUIManager
         schedule();
       }
 
+      if (ReactNativeFeatureFlags.useSharedAnimatedBackend() && mBinding != null) {
+        mBinding.driveAnimationBackend(frameTimeNanos);
+      }
+
       mSynchronousEvents.clear();
     }
   }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManagerBinding.kt

@@ -79,16 +79,12 @@ internal class FabricUIManagerBinding : HybridClassBase() {
 
   external fun driveCxxAnimations()
 
-  external fun driveAnimationBackend(frameTimeMs: Double)
+  external fun driveAnimationBackend(frameTimeNanos: Long)
 
   external fun drainPreallocateViewsQueue()
 
   external fun reportMount(surfaceId: Int)
 
-  external fun setAnimationBackendChoreographer(
-      animationBackendChoreographer: AnimationBackendChoreographer
-  )
-
   external fun mergeReactRevision(surfaceId: Int)
 
   fun register(
@@ -97,13 +93,8 @@ internal class FabricUIManagerBinding : HybridClassBase() {
       fabricUIManager: FabricUIManager,
       eventBeatManager: EventBeatManager,
       componentFactory: ComponentFactory,
-      animationBackendChoreographer: AnimationBackendChoreographer,
   ) {
     fabricUIManager.setBinding(this)
-    animationBackendChoreographer.frameCallback = AnimationFrameCallback { frameTimeMs: Double ->
-      driveAnimationBackend(frameTimeMs)
-    }
-    setAnimationBackendChoreographer(animationBackendChoreographer)
 
     installFabricUIManager(
         runtimeExecutor,

package/ReactAndroid/src/main/java/com/facebook/react/fabric/FabricUIManagerProviderImpl.kt

@@ -58,8 +58,6 @@ public class FabricUIManagerProviderImpl(
     val runtimeExecutor = catalystInstance?.runtimeExecutor
     val runtimeScheduler = catalystInstance?.runtimeScheduler
 
-    val animationBackendChoreographer = AnimationBackendChoreographer(context)
-
     if (runtimeExecutor != null && runtimeScheduler != null) {
       binding.register(
           runtimeExecutor,
@@ -67,7 +65,6 @@ public class FabricUIManagerProviderImpl(
           fabricUIManager,
           eventBeatManager,
           componentFactory,
-          animationBackendChoreographer,
       )
     } else {
       throw IllegalStateException(

package/ReactAndroid/src/main/java/com/facebook/react/fabric/ViewTransitionSnapshotManager.kt

@@ -25,6 +25,7 @@ import com.facebook.react.bridge.UIManagerListener
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.fabric.mounting.MountingManager
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
 
 /**
  * Manages bitmap snapshots of views during view transitions. Captures bitmaps from old views and
@@ -76,9 +77,10 @@ internal class ViewTransitionSnapshotManager(
   }
 
   /**
-   * Captures a bitmap snapshot of the view identified by the given tag. On API 26+, uses PixelCopy
-   * to capture directly from the GPU-composited surface (faster for complex views, captures
-   * hardware-accelerated content). Falls back to View.draw() on older APIs.
+   * Captures a bitmap snapshot of the view identified by the given tag. When
+   * [ReactNativeFeatureFlags.viewTransitionUseHardwareBitmapAndroid] is enabled and API 26+, uses
+   * PixelCopy to capture directly from the GPU-composited surface. Otherwise falls back to
+   * View.draw() which runs synchronously.
    */
   fun captureViewSnapshot(reactTag: Int, surfaceId: Int) {
     UiThreadUtil.runOnUiThread {
@@ -87,15 +89,17 @@ internal class ViewTransitionSnapshotManager(
       val view = smm.getView(reactTag)
       if (view.width <= 0 || view.height <= 0) return@runOnUiThread
 
-      val window =
-          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      if (
+          ReactNativeFeatureFlags.viewTransitionUseHardwareBitmapAndroid() &&
+              Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+      ) {
+        val window =
             (view.context as? com.facebook.react.bridge.ReactContext)?.getCurrentActivity()?.window
-          } else {
-            null
-          }
-
-      if (window != null) {
-        captureHardwareBitmap(view, reactTag, window)
+        if (window != null) {
+          captureHardwareBitmap(view, reactTag, window)
+        } else {
+          captureSoftwareBitmap(view)?.let { onBitmapCaptured(reactTag, it) }
+        }
       } else {
         // Software fallback runs synchronously, so onBitmapCaptured always
         // completes before setViewSnapshot is called.

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/MountItemDispatcher.kt

@@ -412,10 +412,10 @@ internal class MountItemDispatcher(
       }
 
       return buildList {
-            do {
-              queue.poll()?.let { add(it) }
-            } while (queue.isNotEmpty())
-          }
+        do {
+          queue.poll()?.let { add(it) }
+        } while (queue.isNotEmpty())
+      }
           .takeIf { it.isNotEmpty() }
     }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/mounting/MountingManager.kt

@@ -265,7 +265,7 @@ internal class MountingManager(
       return
     }
 
-    getSurfaceManagerForViewEnforced(reactTag).storeSynchronousMountPropsOverride(reactTag, props)
+    getSurfaceManagerForView(reactTag)?.storeSynchronousMountPropsOverride(reactTag, props)
   }
 
   @UiThread
@@ -275,7 +275,7 @@ internal class MountingManager(
       return
     }
 
-    getSurfaceManagerForViewEnforced(reactTag).updatePropsSynchronously(reactTag, props)
+    getSurfaceManagerForView(reactTag)?.updatePropsSynchronously(reactTag, props)
   }
 
   /**
@@ -327,7 +327,7 @@ internal class MountingManager(
               attachmentsPositions,
           )
 
-  fun enqueuePendingEvent(
+  fun dispatchEvent(
       surfaceId: Int,
       reactTag: Int,
       eventName: String,
@@ -338,22 +338,16 @@ internal class MountingManager(
   ) {
     val smm = getSurfaceMountingManager(surfaceId, reactTag)
     if (smm == null) {
-      FLog.d(
+      FLog.i(
           TAG,
-          "Cannot queue event without valid surface mounting manager for tag: %d, surfaceId: %d",
+          "Unable to invoke event %s for tag [%d] in surfaceId [%d]",
+          eventName,
           reactTag,
           surfaceId,
       )
       return
     }
-    smm.enqueuePendingEvent(
-        reactTag,
-        eventName,
-        canCoalesceEvent,
-        params,
-        eventCategory,
-        eventTimestamp,
-    )
+    smm.dispatchEvent(reactTag, eventName, canCoalesceEvent, params, eventCategory, eventTimestamp)
   }
 
   private fun getSurfaceMountingManager(surfaceId: Int, reactTag: Int): SurfaceMountingManager? =