react-native-tvos 0.82.1-0 → 0.83.0-0

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImpl.kt

@@ -39,6 +39,7 @@ import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.common.build.ReactBuildConfig
 import com.facebook.react.devsupport.DefaultDevSupportManagerFactory
+import com.facebook.react.devsupport.DevMenuConfiguration
 import com.facebook.react.devsupport.DevSupportManagerBase
 import com.facebook.react.devsupport.DevSupportManagerFactory
 import com.facebook.react.devsupport.InspectorFlags
@@ -61,6 +62,7 @@ import com.facebook.react.runtime.internal.bolts.Task
 import com.facebook.react.runtime.internal.bolts.TaskCompletionSource
 import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
 import com.facebook.react.uimanager.DisplayMetricsHolder
+import com.facebook.react.uimanager.PixelUtil
 import com.facebook.react.uimanager.events.BlackHoleEventDispatcher
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
@@ -72,6 +74,9 @@ import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicReference
 import kotlin.Unit
 import kotlin.concurrent.Volatile
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 
 /**
  * A ReactHost is an object that manages a single [ReactInstance]. A ReactHost can be constructed
@@ -128,12 +133,12 @@ public class ReactHostImpl(
   private var reactInstance: ReactInstance? = null
 
   private val bridgelessReactContextRef = BridgelessAtomicRef<BridgelessReactContext>()
+  private val id = counter.getAndIncrement()
 
   private val activity = AtomicReference<Activity?>()
   private val lastUsedActivityRef = AtomicReference(WeakReference<Activity?>(null))
-  private val bridgelessReactStateTracker = BridgelessReactStateTracker(ReactBuildConfig.DEBUG)
-  private val reactLifecycleStateManager = ReactLifecycleStateManager(bridgelessReactStateTracker)
-  private val id = counter.getAndIncrement()
+  private val stateTracker = ReactHostStateTracker(id)
+  private val reactLifecycleStateManager = ReactLifecycleStateManager(stateTracker)
   private var memoryPressureListener: MemoryPressureListener? = null
   private var defaultHardwareBackBtnHandler: DefaultHardwareBackBtnHandler? = null
 
@@ -178,11 +183,11 @@ public class ReactHostImpl(
   /** Initialize and run a React Native surface in a background without mounting real views. */
   internal fun prerenderSurface(surface: ReactSurfaceImpl): TaskInterface<Void> {
     val method = "prerenderSurface(surfaceId = ${surface.surfaceID})"
-    log(method, "Schedule")
+    stateTracker.enterState(method, "Schedule")
 
     attachSurface(surface)
     return callAfterGetOrCreateReactInstance(method, bgExecutor) { reactInstance: ReactInstance ->
-      log(method, "Execute")
+      stateTracker.enterState(method, "Execute")
       reactInstance.prerenderSurface(surface)
     }
   }
@@ -195,11 +200,11 @@ public class ReactHostImpl(
    */
   internal fun startSurface(surface: ReactSurfaceImpl): TaskInterface<Void> {
     val method = "startSurface(surfaceId = ${surface.surfaceID})"
-    log(method, "Schedule")
+    stateTracker.enterState(method, "Schedule")
 
     attachSurface(surface)
     return callAfterGetOrCreateReactInstance(method, bgExecutor) { reactInstance: ReactInstance ->
-      log(method, "Execute")
+      stateTracker.enterState(method, "Execute")
       reactInstance.startSurface(surface)
     }
   }
@@ -212,11 +217,11 @@ public class ReactHostImpl(
    */
   internal fun stopSurface(surface: ReactSurfaceImpl): TaskInterface<Void> {
     val method = "stopSurface(surfaceId = ${surface.surfaceID})"
-    log(method, "Schedule")
+    stateTracker.enterState(method, "Schedule")
 
     detachSurface(surface)
     return callWithExistingReactInstance(method, bgExecutor) { reactInstance: ReactInstance ->
-          log(method, "Execute")
+          stateTracker.enterState(method, "Execute")
           reactInstance.stopSurface(surface)
         }
         .makeVoid()
@@ -238,8 +243,7 @@ public class ReactHostImpl(
 
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostResume(activity: Activity?) {
-    val method = "onHostResume(activity)"
-    log(method)
+    stateTracker.enterState("onHostResume(activity)")
 
     currentActivity = activity
 
@@ -249,8 +253,7 @@ public class ReactHostImpl(
 
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostLeaveHint(activity: Activity?) {
-    val method = "onUserLeaveHint(activity)"
-    log(method)
+    stateTracker.enterState("onUserLeaveHint(activity)")
 
     currentReactContext?.onUserLeaveHint(activity)
   }
@@ -258,7 +261,7 @@ public class ReactHostImpl(
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostPause(activity: Activity?) {
     val method = "onHostPause(activity)"
-    log(method)
+    stateTracker.enterState(method)
 
     val currentActivity = this.currentActivity
     if (currentActivity != null) {
@@ -269,7 +272,7 @@ public class ReactHostImpl(
         val isNotSameActivityMessage =
             "Pausing an activity that is not the current activity, this is incorrect! Current activity: $currentActivityClass Paused activity: $activityClass"
         if (ReactNativeFeatureFlags.skipActivityIdentityAssertionOnHostPause()) {
-          log(method, isNotSameActivityMessage)
+          FLog.w(TAG, method, isNotSameActivityMessage)
         } else {
           Assertions.assertCondition(isSameActivity, isNotSameActivityMessage)
         }
@@ -284,8 +287,7 @@ public class ReactHostImpl(
   /** To be called when the host activity is paused. */
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostPause() {
-    val method = "onHostPause()"
-    log(method)
+    stateTracker.enterState("onHostPause()")
 
     maybeEnableDevSupport(false)
     defaultHardwareBackBtnHandler = null
@@ -295,8 +297,7 @@ public class ReactHostImpl(
   /** To be called when the host activity is destroyed. */
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostDestroy() {
-    val method = "onHostDestroy()"
-    log(method)
+    stateTracker.enterState("onHostDestroy()")
 
     maybeEnableDevSupport(false)
     moveToHostDestroy(currentReactContext)
@@ -304,8 +305,7 @@ public class ReactHostImpl(
 
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostDestroy(activity: Activity?) {
-    val method = "onHostDestroy(activity)"
-    log(method)
+    stateTracker.enterState("onHostDestroy(activity)")
 
     val currentActivity = this.currentActivity
 
@@ -370,6 +370,12 @@ public class ReactHostImpl(
     reactInstanceEventListeners.remove(listener)
   }
 
+  override fun setDevMenuConfiguration(config: DevMenuConfiguration) {
+    devSupportManager.devMenuEnabled = config.devMenuEnabled
+    devSupportManager.shakeGestureEnabled = config.shakeGestureEnabled
+    devSupportManager.keyboardShortcutsEnabled = config.keyboardShortcutsEnabled
+  }
+
   /**
    * Entrypoint to reload the ReactInstance. If the ReactInstance is destroying, will wait until
    * destroy is finished, before reloading.
@@ -383,7 +389,7 @@ public class ReactHostImpl(
           {
             val reloadTask =
                 (destroyTask?.let { destroyTask ->
-                      log(
+                      stateTracker.enterState(
                           "reload()",
                           "Waiting for destroy to finish, before reloading React Native.",
                       )
@@ -485,7 +491,7 @@ public class ReactHostImpl(
           {
             val reloadTask = reloadTask
             if (reloadTask != null) {
-              log(
+              stateTracker.enterState(
                   "destroy()",
                   "Reloading React Native. Waiting for reload to finish before destroying React Native.",
               )
@@ -647,12 +653,42 @@ public class ReactHostImpl(
     }
   }
 
+  @ThreadConfined(value = ThreadConfined.UI)
+  override fun setBundleSource(filePath: String) {
+    devSupportManager.bundleFilePath = filePath
+    reload("Change bundle source")
+  }
+
+  @ThreadConfined(value = ThreadConfined.UI)
+  override fun setBundleSource(
+      debugServerHost: String,
+      moduleName: String,
+      queryMapper: (Map<String, String>) -> Map<String, String>,
+  ) {
+    CoroutineScope(Dispatchers.Default).launch {
+      (devSupportManager as DevSupportManagerBase).devServerHelper.closePackagerConnection()
+      val packagerConnectionSettings = devSupportManager.devSettings.packagerConnectionSettings
+      packagerConnectionSettings.setPackagerOptionsUpdater(queryMapper)
+      packagerConnectionSettings.debugServerHost = debugServerHost
+      devSupportManager.jsAppBundleName = moduleName
+      reload("Changed bundle source")
+    }
+  }
+
   @ThreadConfined(ThreadConfined.UI)
   override fun onConfigurationChanged(context: Context) {
     val currentReactContext = this.currentReactContext
     if (currentReactContext != null) {
       if (ReactNativeFeatureFlags.enableFontScaleChangesUpdatingLayout()) {
+        val previousFontScale = PixelUtil.toPixelFromSP(1.0)
         DisplayMetricsHolder.initDisplayMetrics(currentReactContext)
+        val newFontScale = PixelUtil.toPixelFromSP(1.0)
+
+        if (previousFontScale != newFontScale) {
+          synchronized(attachedSurfaces) {
+            attachedSurfaces.forEach { surface -> surface.view?.requestLayout() }
+          }
+        }
       }
 
       val appearanceModule = currentReactContext.getNativeModule(AppearanceModule::class.java)
@@ -671,20 +707,20 @@ public class ReactHostImpl(
 
   internal fun loadBundle(bundleLoader: JSBundleLoader): Task<Boolean> {
     val method = "loadBundle()"
-    log(method, "Schedule")
+    stateTracker.enterState(method, "Schedule")
 
     return callWithExistingReactInstance(method) { reactInstance: ReactInstance ->
-      log(method, "Execute")
+      stateTracker.enterState(method, "Execute")
       reactInstance.loadJSBundle(bundleLoader)
     }
   }
 
   internal fun registerSegment(segmentId: Int, path: String, callback: Callback?): Task<Boolean> {
     val method = "registerSegment(segmentId = \"$segmentId\", path = \"$path\")"
-    log(method, "Schedule")
+    stateTracker.enterState(method, "Schedule")
 
     return callWithExistingReactInstance(method) { reactInstance: ReactInstance ->
-      log(method, "Execute")
+      stateTracker.enterState(method, "Execute")
       reactInstance.registerSegment(segmentId, path)
       checkNotNull(callback).invoke()
     }
@@ -692,7 +728,7 @@ public class ReactHostImpl(
 
   internal fun handleHostException(e: Exception) {
     val method = "handleHostException(message = \"${e.message}\")"
-    log(method)
+    stateTracker.enterState(method)
 
     if (useDevSupport) {
       devSupportManager.handleException(e)
@@ -722,12 +758,12 @@ public class ReactHostImpl(
   }
 
   internal fun attachSurface(surface: ReactSurfaceImpl) {
-    log("attachSurface(surfaceId = ${surface.surfaceID})")
+    stateTracker.enterState("attachSurface(surfaceId = ${surface.surfaceID})")
     synchronized(attachedSurfaces) { attachedSurfaces.add(surface) }
   }
 
   internal fun detachSurface(surface: ReactSurfaceImpl) {
-    log("detachSurface(surfaceId = ${surface.surfaceID})")
+    stateTracker.enterState("detachSurface(surfaceId = ${surface.surfaceID})")
     synchronized(attachedSurfaces) { attachedSurfaces.remove(surface) }
   }
 
@@ -757,8 +793,7 @@ public class ReactHostImpl(
       return it
     }
 
-    val method = "getOrCreateStartTask()"
-    log(method, "Schedule")
+    stateTracker.enterState("getOrCreateStartTask()", "Schedule")
     if (ReactBuildConfig.DEBUG) {
       Assertions.assertCondition(
           ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture(),
@@ -820,7 +855,7 @@ public class ReactHostImpl(
       throwable: Throwable? = null,
   ) {
     val method = "raiseSoftException($callingMethod)"
-    log(method, message)
+    stateTracker.enterState(method, message)
     ReactSoftExceptionLogger.logSoftException(
         TAG,
         ReactNoCrashSoftException("$method: $message", throwable),
@@ -875,14 +910,6 @@ public class ReactHostImpl(
               executor,
           )
 
-  private fun getOrCreateReactContext(): BridgelessReactContext {
-    val method = "getOrCreateReactContext()"
-    return bridgelessReactContextRef.getOrCreate {
-      log(method, "Creating BridgelessReactContext")
-      BridgelessReactContext(context, this)
-    }
-  }
-
   /**
    * Entrypoint to create the ReactInstance.
    *
@@ -903,14 +930,14 @@ public class ReactHostImpl(
   ): Task<ReactInstance> {
     val method = "waitThenCallGetOrCreateReactInstanceTaskWithRetries"
     reloadTask?.let { task ->
-      log(method, "React Native is reloading. Return reload task.")
+      stateTracker.enterState(method, "React Native is reloading. Return reload task.")
       return task
     }
 
     destroyTask?.let { task ->
       val shouldTryAgain = tryNum < maxTries
       if (shouldTryAgain) {
-        log(
+        stateTracker.enterState(
             method,
             "React Native is tearing down.Wait for teardown to finish, before trying again (try count = $tryNum).",
         )
@@ -938,10 +965,10 @@ public class ReactHostImpl(
   @ThreadConfined("ReactHost")
   private fun getOrCreateReactInstanceTask(): Task<ReactInstance> {
     val method = "getOrCreateReactInstanceTask()"
-    log(method)
+    stateTracker.enterState(method)
 
     return createReactInstanceTaskRef.getOrCreate {
-      log(method, "Start")
+      stateTracker.enterState(method, "Start")
       Assertions.assertCondition(
           !hostInvalidated,
           "Cannot start a new ReactInstance on an invalidated ReactHost",
@@ -956,10 +983,14 @@ public class ReactHostImpl(
           jsBundleLoader.onSuccess(
               { task ->
                 val bundleLoader = checkNotNull(task.getResult())
-                val reactContext = getOrCreateReactContext()
+                val reactContext =
+                    bridgelessReactContextRef.getOrCreate {
+                      stateTracker.enterState(method, "Creating BridgelessReactContext")
+                      BridgelessReactContext(context, this)
+                    }
                 reactContext.jsExceptionHandler = devSupportManager
 
-                log(method, "Creating ReactInstance")
+                stateTracker.enterState(method, "Creating ReactInstance")
                 val instance =
                     ReactInstance(
                         reactContext,
@@ -980,10 +1011,13 @@ public class ReactHostImpl(
                 // as TurboModuleManager will handle any concurrent access
                 instance.initializeEagerTurboModules()
 
-                log(method, "Loading JS Bundle")
+                stateTracker.enterState(method, "Loading JS Bundle")
                 instance.loadJSBundle(bundleLoader)
 
-                log(method, "Calling DevSupportManagerBase.onNewReactContextCreated(reactContext)")
+                stateTracker.enterState(
+                    method,
+                    "DevSupportManager.onNewReactContextCreated()",
+                )
                 devSupportManager.onNewReactContextCreated(reactContext)
 
                 reactContext.runOnJSQueueThread {
@@ -1040,7 +1074,7 @@ public class ReactHostImpl(
           reactLifecycleStateManager.resumeReactContextIfHostResumed(reactContext, currentActivity)
         }
 
-        log(method, "Executing ReactInstanceEventListeners")
+        stateTracker.enterState(method, "Executing ReactInstanceEventListeners")
         for (listener in reactInstanceEventListeners) {
           listener.onReactContextInitialized(reactContext)
         }
@@ -1053,8 +1087,17 @@ public class ReactHostImpl(
 
   private val jsBundleLoader: Task<JSBundleLoader>
     get() {
-      val method = "getJSBundleLoader()"
-      log(method)
+      stateTracker.enterState("getJSBundleLoader()")
+
+      if (devSupportManager.bundleFilePath != null) {
+        return try {
+          Task.forResult(
+              JSBundleLoader.createFileLoader(checkNotNull(devSupportManager.bundleFilePath))
+          )
+        } catch (e: Exception) {
+          Task.forError(e)
+        }
+      }
 
       if (useDevSupport && allowPackagerServerAccess) {
         return isMetroRunning.onSuccessTask(
@@ -1093,13 +1136,13 @@ public class ReactHostImpl(
   private val isMetroRunning: Task<Boolean>
     get() {
       val method = "isMetroRunning()"
-      log(method)
+      stateTracker.enterState(method)
 
       val taskCompletionSource = TaskCompletionSource<Boolean>()
       val asyncDevSupportManager = devSupportManager
 
       asyncDevSupportManager.isPackagerRunning { packagerIsRunning: Boolean ->
-        log(method, "Async result = $packagerIsRunning")
+        stateTracker.enterState(method, "Async result = $packagerIsRunning")
         taskCompletionSource.setResult(packagerIsRunning)
       }
 
@@ -1108,7 +1151,7 @@ public class ReactHostImpl(
 
   private fun loadJSBundleFromMetro(): Task<JSBundleLoader> {
     val method = "loadJSBundleFromMetro()"
-    log(method)
+    stateTracker.enterState(method)
 
     val taskCompletionSource = TaskCompletionSource<JSBundleLoader>()
     val asyncDevSupportManager = devSupportManager as DevSupportManagerBase
@@ -1121,7 +1164,7 @@ public class ReactHostImpl(
         bundleURL,
         object : BundleLoadCallback {
           override fun onSuccess() {
-            log(method, "Creating BundleLoader")
+            stateTracker.enterState(method, "Creating BundleLoader")
             val bundleLoader =
                 JSBundleLoader.createCachedBundleFromNetworkLoader(
                     bundleURL,
@@ -1139,16 +1182,8 @@ public class ReactHostImpl(
     return taskCompletionSource.task
   }
 
-  private fun log(method: String, message: String) {
-    bridgelessReactStateTracker.enterState("ReactHost{$id}.$method: $message")
-  }
-
-  private fun log(method: String) {
-    bridgelessReactStateTracker.enterState("ReactHost{$id}.$method")
-  }
-
   private fun stopAttachedSurfaces(method: String, reactInstance: ReactInstance) {
-    log(method, "Stopping all React Native surfaces")
+    stateTracker.enterState(method, "Stopping all React Native surfaces")
     synchronized(attachedSurfaces) {
       for (surface in attachedSurfaces) {
         reactInstance.stopSurface(surface)
@@ -1158,7 +1193,7 @@ public class ReactHostImpl(
   }
 
   private fun startAttachedSurfaces(method: String, reactInstance: ReactInstance) {
-    log(method, "Restarting previously running React Native Surfaces")
+    stateTracker.enterState(method, "Restarting previously running React Native Surfaces")
     synchronized(attachedSurfaces) {
       for (surface in attachedSurfaces) {
         reactInstance.startSurface(surface)
@@ -1225,7 +1260,7 @@ public class ReactHostImpl(
   @ThreadConfined("ReactHost")
   private fun getOrCreateReloadTask(reason: String): Task<ReactInstance> {
     val method = "getOrCreateReloadTask()"
-    log(method)
+    stateTracker.enterState(method)
 
     // Log how React Native is destroyed
     // TODO(T136397487): Remove after Venice is shipped to 100%
@@ -1239,11 +1274,11 @@ public class ReactHostImpl(
 
     // When using the immediate executor, we want to avoid scheduling any further work immediately
     // when destruction is kicked off.
-    log(method, "Resetting createReactInstance task ref")
+    stateTracker.enterState(method, "Resetting createReactInstance task ref")
     return createReactInstanceTaskRef.andReset
         .continueWithTask(
             { task ->
-              log(method, "Starting React Native reload")
+              stateTracker.enterState(method, "Starting React Native reload")
               val reactInstance = taskUnwrapper(task, "1: Starting reload")
 
               unregisterInstanceFromInspector(reactInstance)
@@ -1257,7 +1292,7 @@ public class ReactHostImpl(
                   reactContext != null &&
                       reactLifecycleStateManager.lifecycleState == LifecycleState.RESUMED
               ) {
-                log(method, "Calling ReactContext.onHostPause()")
+                stateTracker.enterState(method, "Calling ReactContext.onHostPause()")
                 reactContext.onHostPause()
               }
               Task.forResult(reactInstance)
@@ -1284,21 +1319,24 @@ public class ReactHostImpl(
               }
 
               memoryPressureListener?.let { listener ->
-                log(method, "Removing memory pressure listener")
+                stateTracker.enterState(method, "Removing memory pressure listener")
                 memoryPressureRouter.removeMemoryPressureListener(listener)
               }
 
               val reactContext = bridgelessReactContextRef.value
               if (reactContext != null) {
-                log(method, "Resetting ReactContext ref")
+                stateTracker.enterState(method, "Resetting ReactContext ref")
                 bridgelessReactContextRef.reset()
 
-                log(method, "Destroying ReactContext")
+                stateTracker.enterState(method, "Destroying ReactContext")
                 reactContext.destroy()
               }
 
               if (useDevSupport && reactContext != null) {
-                log(method, "Calling DevSupportManager.onReactInstanceDestroyed(reactContext)")
+                stateTracker.enterState(
+                    method,
+                    "Calling DevSupportManager.onReactInstanceDestroyed(reactContext)",
+                )
                 devSupportManager.onReactInstanceDestroyed(reactContext)
               }
               task
@@ -1311,14 +1349,14 @@ public class ReactHostImpl(
               if (reactInstance == null) {
                 raiseSoftException(method, "Skipping ReactInstance.destroy(): ReactInstance null")
               } else {
-                log(method, "Resetting ReactInstance ptr")
+                stateTracker.enterState(method, "Resetting ReactInstance ptr")
                 this.reactInstance = null
 
-                log(method, "Destroying ReactInstance")
+                stateTracker.enterState(method, "Destroying ReactInstance")
                 reactInstance.destroy()
               }
 
-              log(method, "Resetting start task ref")
+              stateTracker.enterState(method, "Resetting start task ref")
               startTask = null
 
               // Kickstart a new ReactInstance create
@@ -1355,7 +1393,7 @@ public class ReactHostImpl(
                 )
               }
 
-              log(method, "Resetting reload task ref")
+              stateTracker.enterState(method, "Resetting reload task ref")
               reloadTask = null
               task
             },
@@ -1377,7 +1415,7 @@ public class ReactHostImpl(
   @ThreadConfined("ReactHost")
   private fun getOrCreateDestroyTask(reason: String, ex: Exception?): Task<Void> {
     val method = "getOrCreateDestroyTask()"
-    log(method)
+    stateTracker.enterState(method)
 
     // Log how React Native is destroyed
     // TODO(T136397487): Remove after Venice is shipped to 100%
@@ -1391,11 +1429,11 @@ public class ReactHostImpl(
 
     // When using the immediate executor, we want to avoid scheduling any further work immediately
     // when destruction is kicked off.
-    log(method, "Resetting createReactInstance task ref")
+    stateTracker.enterState(method, "Resetting createReactInstance task ref")
     return createReactInstanceTaskRef.andReset
         .continueWithTask(
             { task: Task<ReactInstance> ->
-              log(method, "Starting React Native destruction")
+              stateTracker.enterState(method, "Starting React Native destruction")
               val reactInstance = taskUnwrapper(task, "1: Starting destroy")
 
               unregisterInstanceFromInspector(reactInstance)
@@ -1410,7 +1448,7 @@ public class ReactHostImpl(
 
               // Step 1: Destroy DevSupportManager
               if (useDevSupport) {
-                log(method, "DevSupportManager cleanup")
+                stateTracker.enterState(method, "DevSupportManager cleanup")
                 // TODO(T137233065): Disable DevSupportManager here
                 devSupportManager.stopInspector()
               }
@@ -1421,7 +1459,7 @@ public class ReactHostImpl(
               }
 
               // Step 2: Move React Native to onHostDestroy()
-              log(method, "Move ReactHost to onHostDestroy()")
+              stateTracker.enterState(method, "Move ReactHost to onHostDestroy()")
               reactLifecycleStateManager.moveToOnHostDestroy(reactContext)
               Task.forResult<ReactInstance>(reactInstance)
             },
@@ -1454,14 +1492,14 @@ public class ReactHostImpl(
               }
 
               // Step 4: De-register the memory pressure listener
-              log(method, "Destroying MemoryPressureRouter")
+              stateTracker.enterState(method, "Destroying MemoryPressureRouter")
               memoryPressureRouter.destroy(context)
 
               if (reactContext != null) {
-                log(method, "Resetting ReactContext ref")
+                stateTracker.enterState(method, "Resetting ReactContext ref")
                 bridgelessReactContextRef.reset()
 
-                log(method, "Destroying ReactContext")
+                stateTracker.enterState(method, "Destroying ReactContext")
                 reactContext.destroy()
               }
 
@@ -1480,17 +1518,15 @@ public class ReactHostImpl(
               if (reactInstance == null) {
                 raiseSoftException(method, "Skipping ReactInstance.destroy(): ReactInstance null")
               } else {
-                log(method, "Resetting ReactInstance ptr")
+                stateTracker.enterState(method, "Resetting ReactInstance ptr")
                 this.reactInstance = null
 
-                log(method, "Destroying ReactInstance")
+                stateTracker.enterState(method, "Destroying ReactInstance")
                 reactInstance.destroy()
               }
 
-              log(method, "Resetting start task ref")
+              stateTracker.enterState(method, "Resetting start/destroy task ref")
               startTask = null
-
-              log(method, "Resetting destroy task ref")
               destroyTask = null
               task
             },

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImplDevHelper.kt

@@ -81,6 +81,6 @@ internal class ReactHostImplDevHelper(private val delegate: ReactHostImpl) :
       delegate.loadBundle(bundleLoader)
 
   override fun getTracingState(): TracingState {
-    return delegate.reactHostInspectorTarget?.tracingState() ?: TracingState.DISABLED
+    return delegate.reactHostInspectorTarget?.getTracingState() ?: TracingState.ENABLEDINCDPMODE
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostInspectorTarget.kt

@@ -37,13 +37,13 @@ internal class ReactHostInspectorTarget(reactHostImpl: ReactHostImpl) :
 
   external fun startBackgroundTrace(): Boolean
 
-  external fun stopAndStashBackgroundTrace()
+  external fun stopAndMaybeEmitBackgroundTrace(): Boolean
 
   external fun stopAndDiscardBackgroundTrace()
 
   external fun tracingStateAsInt(): Int
 
-  fun tracingState(): TracingState {
+  override fun getTracingState(): TracingState {
     return TracingState.entries[tracingStateAsInt()]
   }
 
@@ -51,11 +51,13 @@ internal class ReactHostInspectorTarget(reactHostImpl: ReactHostImpl) :
     perfMonitorListeners.add(listener)
   }
 
-  override fun pauseAndAnalyzeBackgroundTrace() {
-    stopAndStashBackgroundTrace()
+  override fun pauseAndAnalyzeBackgroundTrace(): Boolean {
+    val emitted = stopAndMaybeEmitBackgroundTrace()
     perfMonitorListeners.forEach { listener ->
       listener.onRecordingStateChanged(TracingState.DISABLED)
     }
+
+    return emitted
   }
 
   override fun resumeBackgroundTrace() {
@@ -65,18 +67,19 @@ internal class ReactHostInspectorTarget(reactHostImpl: ReactHostImpl) :
     }
   }
 
-  fun handleNativePerfMonitorMetricUpdate(
-      longTaskDurationMs: Int,
-      responsivenessScore: Int,
-      ttl: Int,
-  ) {
+  override fun stopBackgroundTrace() {
+    stopAndDiscardBackgroundTrace()
     perfMonitorListeners.forEach { listener ->
-      listener.onNewFocusedEvent(
-          PerfMonitorUpdateListener.LongTaskEventData(longTaskDurationMs, responsivenessScore, ttl)
-      )
+      listener.onRecordingStateChanged(TracingState.DISABLED)
     }
   }
 
+  fun handleNativePerfIssueAdded(
+      name: String,
+  ) {
+    perfMonitorListeners.forEach { listener -> listener.onPerfIssueAdded(name) }
+  }
+
   override fun close() {
     mHybridData.resetNative()
   }