react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -0,0 +1,74 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.facebook.react.devsupport.inspector
+
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+
+/**
+ * Shared [OkHttpClient] instances for devsupport networking. Uses a single connection pool and
+ * dispatcher across all dev support HTTP and WebSocket usage. Supports injecting custom request
+ * headers that are applied to every outgoing request via an OkHttp interceptor.
+ */
+public object DevSupportHttpClient {
+  private val customHeaders = ConcurrentHashMap<String, String>()
+
+  private val headerInterceptor = Interceptor { chain ->
+    val builder = chain.request().newBuilder()
+    for ((name, value) in customHeaders) {
+      builder.header(name, value)
+    }
+    chain.proceed(builder.build())
+  }
+
+  /** Client for HTTP requests: connect=5s, write=disabled, read=disabled. */
+  public val httpClient: OkHttpClient =
+      OkHttpClient.Builder()
+          .addInterceptor(headerInterceptor)
+          .connectTimeout(5, TimeUnit.SECONDS)
+          .writeTimeout(0, TimeUnit.MILLISECONDS)
+          .readTimeout(0, TimeUnit.MINUTES)
+          .build()
+
+  /** Client for WebSocket connections: connect=10s, write=10s, read=disabled. */
+  public val websocketClient: OkHttpClient =
+      httpClient
+          .newBuilder()
+          .connectTimeout(10, TimeUnit.SECONDS)
+          .writeTimeout(10, TimeUnit.SECONDS)
+          .build()
+
+  /** Add a custom header to be included in all requests made through both clients. */
+  @JvmStatic
+  public fun addRequestHeader(name: String, value: String) {
+    customHeaders[name] = value
+  }
+
+  /** Remove a previously added custom header. */
+  @JvmStatic
+  public fun removeRequestHeader(name: String) {
+    customHeaders.remove(name)
+  }
+
+  /**
+   * Returns the appropriate HTTP scheme ("http" or "https") for the given host. Uses "https" when
+   * the host specifies port 443 explicitly (e.g. "example.com:443").
+   */
+  @JvmStatic
+  public fun httpScheme(host: String): String = if (host.endsWith(":443")) "https" else "http"
+
+  /**
+   * Returns the appropriate WebSocket scheme ("ws" or "wss") for the given host. Uses "wss" when
+   * the host specifies port 443 explicitly (e.g. "example.com:443").
+   */
+  @JvmStatic public fun wsScheme(host: String): String = if (host.endsWith(":443")) "wss" else "ws"
+}

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

@@ -10,8 +10,7 @@ package com.facebook.react.devsupport.inspector
 internal data class FrameTimingSequence(
     val id: Int,
     val threadId: Int,
-    val beginDrawingTimestamp: Long,
-    val commitTimestamp: Long,
-    val endDrawingTimestamp: Long,
+    val beginTimestamp: Long,
+    val endTimestamp: Long,
     val screenshot: String? = null,
 )

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

@@ -18,72 +18,113 @@ import android.view.PixelCopy
 import android.view.Window
 import com.facebook.proguard.annotations.DoNotStripAny
 import java.io.ByteArrayOutputStream
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 @DoNotStripAny
 internal class FrameTimingsObserver(
-    private val window: Window,
     private val screenshotsEnabled: Boolean,
     private val onFrameTimingSequence: (sequence: FrameTimingSequence) -> Unit,
 ) {
-  private val handler = Handler(Looper.getMainLooper())
+  private val isSupported = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
+  private val mainHandler = Handler(Looper.getMainLooper())
+
   private var frameCounter: Int = 0
-  private var bitmapBuffer: Bitmap? = null
+  @Volatile private var isTracing: Boolean = false
+  @Volatile private var currentWindow: Window? = null
+
+  fun start() {
+    if (!isSupported) {
+      return
+    }
+
+    frameCounter = 0
+    isTracing = true
+
+    // Capture initial screenshot to ensure there's always at least one frame
+    // recorded at the start of tracing, even if no UI changes occur
+    val timestamp = System.nanoTime()
+    emitFrameTiming(timestamp, timestamp)
+
+    currentWindow?.addOnFrameMetricsAvailableListener(frameMetricsListener, mainHandler)
+  }
+
+  fun stop() {
+    if (!isSupported) {
+      return
+    }
+
+    isTracing = false
+
+    currentWindow?.removeOnFrameMetricsAvailableListener(frameMetricsListener)
+    mainHandler.removeCallbacksAndMessages(null)
+  }
+
+  fun setCurrentWindow(window: Window?) {
+    if (!isSupported || currentWindow === window) {
+      return
+    }
+
+    currentWindow?.removeOnFrameMetricsAvailableListener(frameMetricsListener)
+    currentWindow = window
+    if (isTracing) {
+      currentWindow?.addOnFrameMetricsAvailableListener(frameMetricsListener, mainHandler)
+    }
+  }
 
   private val frameMetricsListener =
-      Window.OnFrameMetricsAvailableListener { _, frameMetrics, _dropCount ->
-        val beginDrawingTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
-        val commitTimestamp =
-            beginDrawingTimestamp + frameMetrics.getMetric(FrameMetrics.INPUT_HANDLING_DURATION)
-        +frameMetrics.getMetric(FrameMetrics.ANIMATION_DURATION)
-        +frameMetrics.getMetric(FrameMetrics.LAYOUT_MEASURE_DURATION)
-        +frameMetrics.getMetric(FrameMetrics.DRAW_DURATION)
-        +frameMetrics.getMetric(FrameMetrics.SYNC_DURATION)
-        val endDrawingTimestamp =
-            beginDrawingTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
-
-        val frameId = frameCounter++
-        val threadId = Process.myTid()
+      Window.OnFrameMetricsAvailableListener { _, frameMetrics, _ ->
+        // Guard against calls arriving after stop() has ended tracing. Async work scheduled from
+        // previous frames will still finish.
+        if (!isTracing) {
+          return@OnFrameMetricsAvailableListener
+        }
+        val beginTimestamp = frameMetrics.getMetric(FrameMetrics.VSYNC_TIMESTAMP)
+        val endTimestamp = beginTimestamp + frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)
+        emitFrameTiming(beginTimestamp, endTimestamp)
+      }
 
-        CoroutineScope(Dispatchers.Default).launch {
-          val screenshot = if (screenshotsEnabled) captureScreenshot() else null
+  private fun emitFrameTiming(beginTimestamp: Long, endTimestamp: Long) {
+    val frameId = frameCounter++
+    val threadId = Process.myTid()
 
+    if (screenshotsEnabled) {
+      // Initiate PixelCopy immediately on the main thread, while still in the current frame,
+      // then process and emit asynchronously once the copy is complete.
+      captureScreenshot { screenshot ->
+        CoroutineScope(Dispatchers.Default).launch {
           onFrameTimingSequence(
-              FrameTimingSequence(
-                  frameId,
-                  threadId,
-                  beginDrawingTimestamp,
-                  commitTimestamp,
-                  endDrawingTimestamp,
-                  screenshot,
-              )
+              FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, screenshot)
           )
         }
       }
+    } else {
+      CoroutineScope(Dispatchers.Default).launch {
+        onFrameTimingSequence(
+            FrameTimingSequence(frameId, threadId, beginTimestamp, endTimestamp, null)
+        )
+      }
+    }
+  }
 
-  private suspend fun captureScreenshot(): String? = suspendCoroutine { continuation ->
+  // Must be called from the main thread so that PixelCopy captures the current frame.
+  private fun captureScreenshot(callback: (String?) -> Unit) {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-      continuation.resume(null)
-      return@suspendCoroutine
+      callback(null)
+      return
+    }
+
+    val window = currentWindow
+    if (window == null) {
+      callback(null)
+      return
     }
 
     val decorView = window.decorView
     val width = decorView.width
     val height = decorView.height
-
-    // Reuse bitmap if dimensions haven't changed
-    val bitmap =
-        bitmapBuffer?.let {
-          if (it.width == width && it.height == height) {
-            it
-          } else {
-            null
-          }
-        } ?: Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).also { bitmapBuffer = it }
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
 
     PixelCopy.request(
         window,
@@ -91,54 +132,43 @@ internal class FrameTimingsObserver(
         { copyResult ->
           if (copyResult == PixelCopy.SUCCESS) {
             CoroutineScope(Dispatchers.Default).launch {
-              try {
-                val scaleFactor = 0.25f
-                val scaledWidth = (width * scaleFactor).toInt()
-                val scaledHeight = (height * scaleFactor).toInt()
-                val scaledBitmap =
-                    Bitmap.createScaledBitmap(bitmap, scaledWidth, scaledHeight, true)
-
-                val outputStream = ByteArrayOutputStream()
-                val compressFormat =
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
-                        Bitmap.CompressFormat.WEBP_LOSSY
-                    else Bitmap.CompressFormat.WEBP
-                scaledBitmap.compress(compressFormat, 0, outputStream)
-                val bytes = outputStream.toByteArray()
-                val base64 = Base64.encodeToString(bytes, Base64.NO_WRAP)
-                continuation.resume(base64)
-
-                scaledBitmap.recycle()
-              } catch (e: Exception) {
-                continuation.resume(null)
-              }
+              callback(encodeScreenshot(window, bitmap, width, height))
             }
           } else {
-            continuation.resume(null)
+            bitmap.recycle()
+            callback(null)
           }
         },
-        handler,
+        mainHandler,
     )
   }
 
-  fun start() {
-    frameCounter = 0
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
-      return
+  private fun encodeScreenshot(window: Window, bitmap: Bitmap, width: Int, height: Int): String? {
+    var scaledBitmap: Bitmap? = null
+    return try {
+      val density = window.context.resources.displayMetrics.density
+      val scaledWidth = (width / density * SCREENSHOT_SCALE_FACTOR).toInt()
+      val scaledHeight = (height / density * SCREENSHOT_SCALE_FACTOR).toInt()
+      scaledBitmap = Bitmap.createScaledBitmap(bitmap, scaledWidth, scaledHeight, true)
+
+      val compressFormat =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) Bitmap.CompressFormat.WEBP_LOSSY
+          else Bitmap.CompressFormat.JPEG
+
+      ByteArrayOutputStream().use { outputStream ->
+        scaledBitmap.compress(compressFormat, SCREENSHOT_QUALITY, outputStream)
+        Base64.encodeToString(outputStream.toByteArray(), Base64.NO_WRAP)
+      }
+    } catch (e: Exception) {
+      null
+    } finally {
+      scaledBitmap?.recycle()
+      bitmap.recycle()
     }
-
-    window.addOnFrameMetricsAvailableListener(frameMetricsListener, handler)
   }
 
-  fun stop() {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
-      return
-    }
-
-    window.removeOnFrameMetricsAvailableListener(frameMetricsListener)
-    handler.removeCallbacksAndMessages(null)
-
-    bitmapBuffer?.recycle()
-    bitmapBuffer = null
+  companion object {
+    private const val SCREENSHOT_SCALE_FACTOR = 0.75f
+    private const val SCREENSHOT_QUALITY = 80
   }
 }

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

@@ -10,26 +10,15 @@
 package com.facebook.react.devsupport.inspector
 
 import java.io.IOException
-import java.util.concurrent.TimeUnit
 import okhttp3.Call
 import okhttp3.Callback
-import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
 
 internal object InspectorNetworkHelper {
-  private lateinit var client: OkHttpClient
 
   @JvmStatic
   fun loadNetworkResource(url: String, listener: InspectorNetworkRequestListener) {
-    if (!::client.isInitialized) {
-      client =
-          OkHttpClient.Builder()
-              .connectTimeout(10, TimeUnit.SECONDS)
-              .writeTimeout(10, TimeUnit.SECONDS)
-              .readTimeout(0, TimeUnit.MINUTES) // Disable timeouts for read
-              .build()
-    }
 
     val request =
         try {
@@ -40,7 +29,7 @@ internal object InspectorNetworkHelper {
         }
 
     // TODO(T196951523): Assign cancel function to listener
-    val call = client.newCall(request)
+    val call = DevSupportHttpClient.httpClient.newCall(request)
 
     call.enqueue(
         object : Callback {

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

@@ -10,7 +10,7 @@ package com.facebook.react.devsupport.interfaces
 public interface DevBundleDownloadListener {
   public fun onSuccess()
 
-  public fun onProgress(status: String?, done: Int?, total: Int?)
+  public fun onProgress(status: String?, done: Int?, total: Int?, percent: Int?)
 
   public fun onFailure(cause: Exception)
 }

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

@@ -18,7 +18,7 @@ public interface DevLoadingViewManager {
       dismissButton: Boolean?,
   )
 
-  public fun updateProgress(status: String?, done: Int?, total: Int?)
+  public fun updateProgress(status: String?, done: Int?, total: Int?, percent: Int?)
 
   public fun hide()
 }

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

@@ -0,0 +1,87 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.fabric
+
+import com.facebook.proguard.annotations.DoNotStripAny
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.modules.core.ReactChoreographer
+import com.facebook.react.uimanager.GuardedFrameCallback
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.synchronized
+
+internal fun interface AnimationFrameCallback {
+  fun onAnimationFrame(frameTimeMs: Double)
+}
+
+@DoNotStripAny
+internal class AnimationBackendChoreographer(
+    reactApplicationContext: ReactApplicationContext,
+) {
+
+  var frameCallback: AnimationFrameCallback? = null
+  private var lastFrameTimeMs: Double = 0.0
+  private val reactChoreographer: ReactChoreographer = ReactChoreographer.getInstance()
+  private val choreographerCallback: GuardedFrameCallback =
+      object : GuardedFrameCallback(reactApplicationContext) {
+        override fun doFrameGuarded(frameTimeNanos: Long) {
+          executeFrameCallback(frameTimeNanos)
+        }
+      }
+  private val callbackPosted: AtomicBoolean = AtomicBoolean()
+  private val paused: AtomicBoolean = AtomicBoolean(true)
+
+  /*
+   * resume() and pause() should be called with the same lock to avoid race conditions.
+   */
+
+  fun resume() {
+    if (paused.getAndSet(false)) {
+      scheduleCallback()
+    }
+  }
+
+  fun pause() {
+    synchronized(paused) {
+      if (!paused.getAndSet(true) && callbackPosted.getAndSet(false)) {
+        reactChoreographer.removeFrameCallback(
+            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+            choreographerCallback,
+        )
+      }
+    }
+  }
+
+  private fun scheduleCallback() {
+    synchronized(paused) {
+      if (!paused.get() && !callbackPosted.getAndSet(true)) {
+        reactChoreographer.postFrameCallback(
+            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
+            choreographerCallback,
+        )
+      }
+    }
+  }
+
+  private fun executeFrameCallback(frameTimeNanos: Long) {
+    callbackPosted.set(false)
+    val currentFrameTimeMs = calculateTimestamp(frameTimeNanos)
+    // It is possible for ChoreographerCallback to be executed twice within the same frame
+    // due to frame drops. If this occurs, the additional callback execution should be ignored.
+    if (currentFrameTimeMs > lastFrameTimeMs) {
+      frameCallback?.onAnimationFrame(currentFrameTimeMs)
+    }
+
+    lastFrameTimeMs = currentFrameTimeMs
+    scheduleCallback()
+  }
+
+  private fun calculateTimestamp(frameTimeNanos: Long): Double {
+    val nanosecondsInMilliseconds = 1000000.0
+    return frameTimeNanos / nanosecondsInMilliseconds
+  }
+}

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

@@ -117,7 +117,9 @@ public class FabricUIManager
 
   // The IS_DEVELOPMENT_ENVIRONMENT variable is used to log extra data when running fabric in a
   // development environment. DO NOT ENABLE THIS ON PRODUCTION OR YOU WILL BE FIRED!
+  @SuppressLint("ClownyBooleanExpression")
   public static final boolean IS_DEVELOPMENT_ENVIRONMENT = false && ReactBuildConfig.DEBUG;
+
   public @Nullable DevToolsReactPerfLogger mDevToolsReactPerfLogger;
 
   private static final DevToolsReactPerfLogger.DevToolsReactPerfLoggerListener FABRIC_PERF_LOGGER =
@@ -685,7 +687,9 @@ public class FabricUIManager
         preparedLayout.getLayout(),
         preparedLayout.getMaximumNumberOfLines(),
         preparedLayout.getVerticalOffset(),
-        reactTags);
+        reactTags,
+        preparedLayout.getTextBreakStrategy(),
+        preparedLayout.getJustificationMode());
   }
 
   @AnyThread
@@ -818,14 +822,15 @@ public class FabricUIManager
         ReactMarkerConstants.FABRIC_UPDATE_UI_MAIN_THREAD_END, null, commitNumber);
   }
 
+  @SuppressLint("NotInvokedPrivateMethod")
   @SuppressWarnings("unused")
   @AnyThread
   @ThreadConfined(ANY)
   private void preallocateView(
       int rootTag,
       int reactTag,
-      final String componentName,
-      @Nullable Object props,
+      String componentName,
+      Object props,
       @Nullable Object stateWrapper,
       boolean isLayoutable) {
     mMountItemDispatcher.addPreAllocateMountItem(
@@ -838,6 +843,7 @@ public class FabricUIManager
             isLayoutable));
   }
 
+  @SuppressLint("NotInvokedPrivateMethod") // Called from C++ via JNI
   @SuppressWarnings("unused")
   @AnyThread
   @ThreadConfined(ANY)
@@ -871,6 +877,7 @@ public class FabricUIManager
    * to enforce execution order using {@link ReactChoreographer.CallbackType}. This method should
    * only be called as the result of a new tree being committed.
    */
+  @SuppressLint("NotInvokedPrivateMethod") // Called from C++ via JNI (Binding.cpp)
   @SuppressWarnings("unused")
   @AnyThread
   @ThreadConfined(ANY)
@@ -959,6 +966,25 @@ public class FabricUIManager
     }
   }
 
+  @SuppressWarnings("unused")
+  @AnyThread
+  @ThreadConfined(ANY)
+  private void scheduleReactRevisionMerge(int surfaceId) {
+    if (UiThreadUtil.isOnUiThread()) {
+      if (mBinding != null) {
+        mBinding.mergeReactRevision(surfaceId);
+      }
+    } else {
+      UiThreadUtil.runOnUiThread(
+          () -> {
+            FabricUIManagerBinding binding = mBinding;
+            if (binding != null) {
+              binding.mergeReactRevision(surfaceId);
+            }
+          });
+    }
+  }
+
   /**
    * This method initiates preloading of an image specified by ImageSource. It can later be consumed
    * by an ImageView.
@@ -1035,7 +1061,10 @@ public class FabricUIManager
     UiThreadUtil.assertOnUiThread();
 
     SurfaceMountingManager surfaceManager = mMountingManager.getSurfaceManagerForView(reactTag);
-    return surfaceManager == null ? null : surfaceManager.getView(reactTag);
+    if (surfaceManager == null || surfaceManager.isStopped()) {
+      return null;
+    }
+    return surfaceManager.getView(reactTag);
   }
 
   @Override
@@ -1050,11 +1079,11 @@ public class FabricUIManager
   }
 
   /**
-   * receiveEvent API that emits an event to C++. If `canCoalesceEvent` is true, that signals that
-   * C++ may coalesce the event optionally. Otherwise, coalescing can happen in Java before
+   * receiveEvent API that emits an event to C++. If {@code canCoalesceEvent} is true, that signals
+   * that C++ may coalesce the event optionally. Otherwise, coalescing can happen in Java before
    * emitting.
    *
-   * <p>`customCoalesceKey` is currently unused.
+   * <p>{@code customCoalesceKey} is currently unused.
    *
    * @param surfaceId
    * @param reactTag

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

@@ -9,14 +9,14 @@ package com.facebook.react.fabric
 
 import android.annotation.SuppressLint
 import com.facebook.jni.HybridClassBase
-import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.proguard.annotations.DoNotStripAny
 import com.facebook.react.bridge.NativeMap
 import com.facebook.react.bridge.RuntimeExecutor
 import com.facebook.react.bridge.RuntimeScheduler
 import com.facebook.react.fabric.events.EventBeatManager
 import com.facebook.react.uimanager.PixelUtil.getDisplayMetricDensity
 
-@DoNotStrip
+@DoNotStripAny
 @SuppressLint("MissingNativeLoadLibrary")
 internal class FabricUIManagerBinding : HybridClassBase() {
   init {
@@ -79,18 +79,32 @@ internal class FabricUIManagerBinding : HybridClassBase() {
 
   external fun driveCxxAnimations()
 
+  external fun driveAnimationBackend(frameTimeMs: Double)
+
   external fun drainPreallocateViewsQueue()
 
   external fun reportMount(surfaceId: Int)
 
+  external fun setAnimationBackendChoreographer(
+      animationBackendChoreographer: AnimationBackendChoreographer
+  )
+
+  external fun mergeReactRevision(surfaceId: Int)
+
   fun register(
       runtimeExecutor: RuntimeExecutor,
       runtimeScheduler: RuntimeScheduler,
       fabricUIManager: FabricUIManager,
       eventBeatManager: EventBeatManager,
       componentFactory: ComponentFactory,
+      animationBackendChoreographer: AnimationBackendChoreographer,
   ) {
     fabricUIManager.setBinding(this)
+    animationBackendChoreographer.frameCallback = AnimationFrameCallback { frameTimeMs: Double ->
+      driveAnimationBackend(frameTimeMs)
+    }
+    setAnimationBackendChoreographer(animationBackendChoreographer)
+
     installFabricUIManager(
         runtimeExecutor,
         runtimeScheduler,

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

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

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

@@ -49,14 +49,14 @@ internal class LongStreamingStats {
 
   val median: Double
     get() {
-      if (minHeap.size == 0 && maxHeap.size == 0) {
+      if (minHeap.isEmpty() && maxHeap.isEmpty()) {
         return 0.0
       }
       val median =
           if (minHeap.size > maxHeap.size) {
             minHeap.peek()
           } else {
-            (minHeap.peek() ?: 0 + maxHeap.peek()!!) / 2
+            ((minHeap.peek() ?: 0L) + (maxHeap.peek() ?: 0L)) / 2
           }
       return median.toDouble()
     }

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

@@ -13,12 +13,6 @@ import com.facebook.react.fabric.mounting.LayoutMetricsConversions
 
 internal open class SurfaceHandlerBinding(moduleName: String) : HybridClassBase() {
 
-  init {
-    initHybrid(NO_SURFACE_ID, moduleName)
-  }
-
-  private external fun initHybrid(surfaceId: Int, moduleName: String)
-
   val surfaceId: Int
     get() = _getSurfaceId()
 
@@ -28,6 +22,12 @@ internal open class SurfaceHandlerBinding(moduleName: String) : HybridClassBase(
   val moduleName: String
     get() = _getModuleName()
 
+  init {
+    initHybrid(NO_SURFACE_ID, moduleName)
+  }
+
+  private external fun initHybrid(surfaceId: Int, moduleName: String)
+
   private external fun _getSurfaceId(): Int
 
   private external fun _getModuleName(): String