react-native-tvos 0.81.3-0 → 0.82.0-0

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

@@ -29,7 +29,6 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReactMarker
 import com.facebook.react.bridge.ReactMarkerConstants
-import com.facebook.react.bridge.ReactNoCrashBridgeNotAllowedSoftException
 import com.facebook.react.bridge.ReactNoCrashSoftException
 import com.facebook.react.bridge.ReactSoftExceptionLogger
 import com.facebook.react.bridge.RuntimeExecutor
@@ -62,7 +61,6 @@ 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.UIManagerModule
 import com.facebook.react.uimanager.events.BlackHoleEventDispatcher
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
@@ -97,20 +95,30 @@ public class ReactHostImpl(
     private val useDevSupport: Boolean,
     devSupportManagerFactory: DevSupportManagerFactory? = null,
 ) : ReactHost {
+  private val reactHostImplDevHelper = ReactHostImplDevHelper(this)
+
   public override val devSupportManager: DevSupportManager =
-      (devSupportManagerFactory ?: DefaultDevSupportManagerFactory()).create(
-          applicationContext = context.applicationContext,
-          reactInstanceManagerHelper = ReactHostImplDevHelper(this),
-          packagerPathForJSBundleName = reactHostDelegate.jsMainModulePath,
-          enableOnCreate = true,
-          redBoxHandler = null,
-          devBundleDownloadListener = null,
-          minNumShakes = 2,
-          customPackagerCommandHandlers = null,
-          surfaceDelegateFactory = null,
-          devLoadingViewManager = null,
-          pausedInDebuggerOverlayManager = null,
-          useDevSupport = useDevSupport)
+      (devSupportManagerFactory ?: DefaultDevSupportManagerFactory())
+          .create(
+              applicationContext = context.applicationContext,
+              reactInstanceManagerHelper = reactHostImplDevHelper,
+              packagerPathForJSBundleName = reactHostDelegate.jsMainModulePath,
+              enableOnCreate = true,
+              redBoxHandler = null,
+              devBundleDownloadListener = null,
+              minNumShakes = 2,
+              customPackagerCommandHandlers = null,
+              surfaceDelegateFactory = null,
+              devLoadingViewManager = null,
+              pausedInDebuggerOverlayManager = null,
+              useDevSupport = useDevSupport,
+          )
+          .also { devSupportManager ->
+            // Wire up the tracing state provider
+            if (devSupportManager is DevSupportManagerBase) {
+              devSupportManager.setTracingStateProvider(reactHostImplDevHelper)
+            }
+          }
   public override val memoryPressureRouter: MemoryPressureRouter = MemoryPressureRouter(context)
 
   private val attachedSurfaces: MutableSet<ReactSurfaceImpl> = HashSet()
@@ -133,7 +141,7 @@ public class ReactHostImpl(
       CopyOnWriteArrayList()
   private val beforeDestroyListeners: MutableList<() -> Unit> = CopyOnWriteArrayList()
 
-  private var reactHostInspectorTarget: ReactHostInspectorTarget? = null
+  internal var reactHostInspectorTarget: ReactHostInspectorTarget? = null
 
   @Volatile private var hostInvalidated = false
 
@@ -142,7 +150,7 @@ public class ReactHostImpl(
       delegate: ReactHostDelegate,
       componentFactory: ComponentFactory,
       allowPackagerServerAccess: Boolean,
-      useDevSupport: Boolean
+      useDevSupport: Boolean,
   ) : this(
       context,
       delegate,
@@ -150,7 +158,8 @@ public class ReactHostImpl(
       Executors.newSingleThreadExecutor(),
       Task.UI_THREAD_EXECUTOR,
       allowPackagerServerAccess,
-      useDevSupport)
+      useDevSupport,
+  )
 
   public override val lifecycleState: LifecycleState
     get() = reactLifecycleStateManager.lifecycleState
@@ -221,7 +230,7 @@ public class ReactHostImpl(
   @ThreadConfined(ThreadConfined.UI)
   override fun onHostResume(
       activity: Activity?,
-      defaultBackButtonImpl: DefaultHardwareBackBtnHandler?
+      defaultBackButtonImpl: DefaultHardwareBackBtnHandler?,
   ) {
     defaultHardwareBackBtnHandler = defaultBackButtonImpl
     onHostResume(activity)
@@ -253,11 +262,18 @@ public class ReactHostImpl(
 
     val currentActivity = this.currentActivity
     if (currentActivity != null) {
-      val currentActivityClass = currentActivity.javaClass.simpleName
-      val activityClass = if (activity == null) "null" else activity.javaClass.simpleName
-      Assertions.assertCondition(
-          activity === currentActivity,
-          "Pausing an activity that is not the current activity, this is incorrect! Current activity: $currentActivityClass Paused activity: $activityClass")
+      val isSameActivity = activity === currentActivity
+      if (!isSameActivity) {
+        val currentActivityClass = currentActivity.javaClass.simpleName
+        val activityClass = if (activity == null) "null" else activity.javaClass.simpleName
+        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)
+        } else {
+          Assertions.assertCondition(isSameActivity, isNotSameActivityMessage)
+        }
+      }
     }
 
     maybeEnableDevSupport(false)
@@ -316,7 +332,7 @@ public class ReactHostImpl(
   override fun createSurface(
       context: Context,
       moduleName: String,
-      initialProps: Bundle?
+      initialProps: Bundle?,
   ): ReactSurface {
     val surface = ReactSurfaceImpl(context, moduleName, initialProps)
     val surfaceView = ReactSurfaceView(context, surface)
@@ -369,7 +385,8 @@ public class ReactHostImpl(
                 (destroyTask?.let { destroyTask ->
                       log(
                           "reload()",
-                          "Waiting for destroy to finish, before reloading React Native.")
+                          "Waiting for destroy to finish, before reloading React Native.",
+                      )
                       destroyTask.continueWithTask({ getOrCreateReloadTask(reason) }, bgExecutor)
                     } ?: getOrCreateReloadTask(reason))
                     .makeVoid()
@@ -387,9 +404,11 @@ public class ReactHostImpl(
                     task
                   }
                 },
-                bgExecutor)
+                bgExecutor,
+            )
           },
-          bgExecutor)
+          bgExecutor,
+      )
 
   @DoNotStrip
   private fun setPausedInDebuggerMessage(message: String?) {
@@ -403,7 +422,8 @@ public class ReactHostImpl(
               UiThreadUtil.assertOnUiThread()
               reactHostInspectorTarget?.sendDebuggerResumeCommand()
             }
-          })
+          },
+      )
     }
   }
 
@@ -436,7 +456,7 @@ public class ReactHostImpl(
   override fun destroy(
       reason: String,
       ex: Exception?,
-      onDestroyFinished: (instanceDestroyedSuccessfully: Boolean) -> Unit
+      onDestroyFinished: (instanceDestroyedSuccessfully: Boolean) -> Unit,
   ): TaskInterface<Void> {
     val destroyTask = destroy(reason, ex) as Task<Void>
     return destroyTask.continueWith({ task: Task<Void> ->
@@ -467,13 +487,15 @@ public class ReactHostImpl(
             if (reloadTask != null) {
               log(
                   "destroy()",
-                  "Reloading React Native. Waiting for reload to finish before destroying React Native.")
+                  "Reloading React Native. Waiting for reload to finish before destroying React Native.",
+              )
               reloadTask.continueWithTask<Void>({ getOrCreateDestroyTask(reason, ex) }, bgExecutor)
             } else {
               getOrCreateDestroyTask(reason, ex)
             }
           },
-          bgExecutor)
+          bgExecutor,
+      )
 
   private fun createMemoryPressureListener(reactInstance: ReactInstance): MemoryPressureListener {
     val weakReactInstance = WeakReference(reactInstance)
@@ -517,13 +539,18 @@ public class ReactHostImpl(
   internal val nativeModules: Collection<NativeModule>
     get() = reactInstance?.nativeModules ?: listOf()
 
+  @Suppress("DEPRECATION")
   internal fun <T : NativeModule> getNativeModule(nativeModuleInterface: Class<T>): T? {
-    if (!ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE &&
-        nativeModuleInterface == UIManagerModule::class.java) {
+    if (
+        !ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE &&
+            nativeModuleInterface == com.facebook.react.uimanager.UIManagerModule::class.java
+    ) {
       ReactSoftExceptionLogger.logSoftExceptionVerbose(
           TAG,
-          ReactNoCrashBridgeNotAllowedSoftException(
-              "getNativeModule(UIManagerModule.class) cannot be called when the bridge is disabled"))
+          ReactNoCrashSoftException(
+              "getNativeModule(UIManagerModule.class) cannot be called when the bridge is disabled"
+          ),
+      )
     }
 
     return reactInstance?.getNativeModule(nativeModuleInterface)
@@ -539,7 +566,9 @@ public class ReactHostImpl(
       }
 
       raiseSoftException(
-          "getRuntimeExecutor()", "Tried to get runtime executor while instance is not ready")
+          "getRuntimeExecutor()",
+          "Tried to get runtime executor while instance is not ready",
+      )
       return null
     }
 
@@ -551,7 +580,8 @@ public class ReactHostImpl(
 
       raiseSoftException(
           "getJSCallInvokerHolder()",
-          "Tried to get JSCallInvokerHolder while instance is not ready")
+          "Tried to get JSCallInvokerHolder while instance is not ready",
+      )
       return null
     }
 
@@ -565,7 +595,7 @@ public class ReactHostImpl(
       activity: Activity,
       requestCode: Int,
       resultCode: Int,
-      data: Intent?
+      data: Intent?,
   ) {
     val method =
         "onActivityResult(activity = \"$activity\", requestCode = \"$requestCode\", resultCode = \"$resultCode\", data = \"$data\")"
@@ -602,8 +632,10 @@ public class ReactHostImpl(
       val action = intent.action
       val uri = intent.data
 
-      if (uri != null &&
-          (Intent.ACTION_VIEW == action || NfcAdapter.ACTION_NDEF_DISCOVERED == action)) {
+      if (
+          uri != null &&
+              (Intent.ACTION_VIEW == action || NfcAdapter.ACTION_NDEF_DISCOVERED == action)
+      ) {
         val deviceEventManagerModule =
             currentContext.getNativeModule(DeviceEventManagerModule::class.java)
         deviceEventManagerModule?.emitNewIntentReceived(uri)
@@ -658,7 +690,7 @@ public class ReactHostImpl(
     }
   }
 
-  internal fun handleHostException(e: Exception): Unit {
+  internal fun handleHostException(e: Exception) {
     val method = "handleHostException(message = \"${e.message}\")"
     log(method)
 
@@ -681,7 +713,7 @@ public class ReactHostImpl(
   internal fun callFunctionOnModule(
       moduleName: String,
       methodName: String,
-      args: NativeArray
+      args: NativeArray,
   ): Task<Boolean> {
     val method = "callFunctionOnModule(\"$moduleName\", \"$methodName\")"
     return callWithExistingReactInstance(method) { reactInstance: ReactInstance ->
@@ -730,23 +762,28 @@ public class ReactHostImpl(
     if (ReactBuildConfig.DEBUG) {
       Assertions.assertCondition(
           ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture(),
-          "enableBridgelessArchitecture FeatureFlag must be set to start ReactNative.")
+          "enableBridgelessArchitecture FeatureFlag must be set to start ReactNative.",
+      )
 
       Assertions.assertCondition(
           ReactNativeNewArchitectureFeatureFlags.enableFabricRenderer(),
-          "enableFabricRenderer FeatureFlag must be set to start ReactNative.")
+          "enableFabricRenderer FeatureFlag must be set to start ReactNative.",
+      )
 
       Assertions.assertCondition(
           ReactNativeNewArchitectureFeatureFlags.useTurboModules(),
-          "useTurboModules FeatureFlag must be set to start ReactNative.")
+          "useTurboModules FeatureFlag must be set to start ReactNative.",
+      )
     }
     if (ReactBuildConfig.UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE) {
       Assertions.assertCondition(
           !ReactNativeNewArchitectureFeatureFlags.useFabricInterop(),
-          "useFabricInterop FeatureFlag must be false when UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE == true.")
+          "useFabricInterop FeatureFlag must be false when UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE == true.",
+      )
       Assertions.assertCondition(
           !ReactNativeNewArchitectureFeatureFlags.useTurboModuleInterop(),
-          "useTurboModuleInterop FeatureFlag must be false when UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE == true.")
+          "useTurboModuleInterop FeatureFlag must be false when UNSTABLE_ENABLE_MINIFY_LEGACY_ARCHITECTURE == true.",
+      )
     }
 
     return waitThenCallGetOrCreateReactInstanceTask()
@@ -766,7 +803,8 @@ public class ReactHostImpl(
                 task.makeVoid()
               }
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .also { startTask = it }
   }
 
@@ -779,12 +817,14 @@ public class ReactHostImpl(
   private fun raiseSoftException(
       callingMethod: String,
       message: String,
-      throwable: Throwable? = null
+      throwable: Throwable? = null,
   ) {
     val method = "raiseSoftException($callingMethod)"
     log(method, message)
     ReactSoftExceptionLogger.logSoftException(
-        TAG, ReactNoCrashSoftException("$method: $message", throwable))
+        TAG,
+        ReactNoCrashSoftException("$method: $message", throwable),
+    )
   }
 
   /** Schedule work on a ReactInstance that is already created. */
@@ -801,14 +841,16 @@ public class ReactHostImpl(
                 if (reactInstance == null) {
                   raiseSoftException(
                       "callWithExistingReactInstance($callingMethod)",
-                      "Execute: reactInstance is null. Dropping work.")
+                      "Execute: reactInstance is null. Dropping work.",
+                  )
                   false
                 } else {
                   runnable(reactInstance)
                   true
                 }
               },
-              executor)
+              executor,
+          )
 
   /** Create a ReactInstance if it doesn't exist already, and schedule work on it. */
   private fun callAfterGetOrCreateReactInstance(
@@ -823,20 +865,15 @@ public class ReactHostImpl(
                 if (reactInstance == null) {
                   raiseSoftException(
                       "callAfterGetOrCreateReactInstance($callingMethod)",
-                      "Execute: reactInstance is null. Dropping work.")
+                      "Execute: reactInstance is null. Dropping work.",
+                  )
                 } else {
                   runnable(reactInstance)
                 }
                 null
               },
-              executor)
-          .continueWith({ task: Task<Void> ->
-            // TODO: validate whether errors during startup go through here?
-            if (task.isFaulted()) {
-              handleHostException(checkNotNull(task.getError()))
-            }
-            null
-          })
+              executor,
+          )
 
   private fun getOrCreateReactContext(): BridgelessReactContext {
     val method = "getOrCreateReactContext()"
@@ -862,7 +899,7 @@ public class ReactHostImpl(
   @ThreadConfined("ReactHost")
   private fun waitThenCallGetOrCreateReactInstanceTaskWithRetries(
       tryNum: Int,
-      maxTries: Int
+      maxTries: Int,
   ): Task<ReactInstance> {
     val method = "waitThenCallGetOrCreateReactInstanceTaskWithRetries"
     reloadTask?.let { task ->
@@ -875,15 +912,18 @@ public class ReactHostImpl(
       if (shouldTryAgain) {
         log(
             method,
-            "React Native is tearing down.Wait for teardown to finish, before trying again (try count = $tryNum).")
+            "React Native is tearing down.Wait for teardown to finish, before trying again (try count = $tryNum).",
+        )
         return task.onSuccessTask(
             { waitThenCallGetOrCreateReactInstanceTaskWithRetries(tryNum + 1, maxTries) },
-            bgExecutor)
+            bgExecutor,
+        )
       }
 
       raiseSoftException(
           method,
-          "React Native is tearing down. Not wait for teardown to finish: reached max retries.")
+          "React Native is tearing down. Not wait for teardown to finish: reached max retries.",
+      )
     }
 
     return getOrCreateReactInstanceTask()
@@ -892,7 +932,7 @@ public class ReactHostImpl(
   private class CreationResult(
       val instance: ReactInstance,
       val context: ReactContext,
-      val isReloading: Boolean
+      val isReloading: Boolean,
   )
 
   @ThreadConfined("ReactHost")
@@ -903,17 +943,21 @@ public class ReactHostImpl(
     return createReactInstanceTaskRef.getOrCreate {
       log(method, "Start")
       Assertions.assertCondition(
-          !hostInvalidated, "Cannot start a new ReactInstance on an invalidated ReactHost")
+          !hostInvalidated,
+          "Cannot start a new ReactInstance on an invalidated ReactHost",
+      )
 
       ReactMarker.logMarker(
-          ReactMarkerConstants.REACT_BRIDGELESS_LOADING_START, BRIDGELESS_MARKER_INSTANCE_KEY)
+          ReactMarkerConstants.REACT_BRIDGELESS_LOADING_START,
+          BRIDGELESS_MARKER_INSTANCE_KEY,
+      )
 
       val creationTask =
           jsBundleLoader.onSuccess(
               { task ->
                 val bundleLoader = checkNotNull(task.getResult())
                 val reactContext = getOrCreateReactContext()
-                reactContext.setJSExceptionHandler(devSupportManager)
+                reactContext.jsExceptionHandler = devSupportManager
 
                 log(method, "Creating ReactInstance")
                 val instance =
@@ -924,7 +968,8 @@ public class ReactHostImpl(
                         devSupportManager,
                         { e: Exception -> this.handleHostException(e) },
                         useDevSupport,
-                        getOrCreateReactHostInspectorTarget())
+                        getOrCreateReactHostInspectorTarget(),
+                    )
                 reactInstance = instance
 
                 val memoryPressureListener = createMemoryPressureListener(instance)
@@ -947,15 +992,22 @@ public class ReactHostImpl(
                   // TODO T76081936 Move this if we switch to a sync RTE
                   ReactMarker.logMarker(
                       ReactMarkerConstants.REACT_BRIDGELESS_LOADING_END,
-                      BRIDGELESS_MARKER_INSTANCE_KEY)
+                      BRIDGELESS_MARKER_INSTANCE_KEY,
+                  )
                 }
                 CreationResult(instance, reactContext, reloadTask != null)
               },
-              bgExecutor)
+              bgExecutor,
+          )
+
+      val lifecycleUpdateTask = task@{ task: Task<CreationResult> ->
+        if (task.isFaulted()) {
+          // handleHostException may throw, so move it outside of the task scheduler
+          uiExecutor.execute { handleHostException(checkNotNull(task.getError())) }
+          return@task
+        }
 
-      val lifecycleUpdateTask = { task: Task<CreationResult> ->
         val result = checkNotNull(task.getResult())
-        val reactInstance = result.instance
         val reactContext = result.context
         val isReloading = result.isReloading
         val isManagerResumed = reactLifecycleStateManager.lifecycleState == LifecycleState.RESUMED
@@ -992,10 +1044,9 @@ public class ReactHostImpl(
         for (listener in reactInstanceEventListeners) {
           listener.onReactContextInitialized(reactContext)
         }
-        reactInstance
       }
 
-      creationTask.onSuccess(lifecycleUpdateTask, uiExecutor)
+      creationTask.continueWith(lifecycleUpdateTask, uiExecutor)
       creationTask.onSuccess({ task -> checkNotNull(task.getResult()).instance })
     }
   }
@@ -1017,7 +1068,8 @@ public class ReactHostImpl(
                 Task.forResult(reactHostDelegate.jsBundleLoader)
               }
             },
-            bgExecutor)
+            bgExecutor,
+        )
       } else {
         if (ReactBuildConfig.DEBUG) {
           FLog.d(TAG, "Packager server access is disabled in this environment")
@@ -1062,7 +1114,8 @@ public class ReactHostImpl(
     val asyncDevSupportManager = devSupportManager as DevSupportManagerBase
     val bundleURL =
         asyncDevSupportManager.devServerHelper.getDevServerBundleURL(
-            checkNotNull(asyncDevSupportManager.jsAppBundleName))
+            checkNotNull(asyncDevSupportManager.jsAppBundleName)
+        )
 
     asyncDevSupportManager.reloadJSFromServer(
         bundleURL,
@@ -1071,14 +1124,17 @@ public class ReactHostImpl(
             log(method, "Creating BundleLoader")
             val bundleLoader =
                 JSBundleLoader.createCachedBundleFromNetworkLoader(
-                    bundleURL, asyncDevSupportManager.downloadedJSBundleFile)
+                    bundleURL,
+                    asyncDevSupportManager.downloadedJSBundleFile,
+                )
             taskCompletionSource.setResult(bundleLoader)
           }
 
           override fun onError(cause: Exception) {
             taskCompletionSource.setError(cause)
           }
-        })
+        },
+    )
 
     return taskCompletionSource.task
   }
@@ -1115,7 +1171,7 @@ public class ReactHostImpl(
   private fun createReactInstanceUnwrapper(
       tag: String,
       method: String,
-      reason: String
+      reason: String,
   ): (task: Task<ReactInstance>, stage: String) -> ReactInstance? =
       unwrap@{ task: Task<ReactInstance>, stage: String ->
         val reactInstance = task.getResult()
@@ -1127,26 +1183,33 @@ public class ReactHostImpl(
           val ex = checkNotNull(task.getError())
           val faultLabel = "Fault reason: ${ex.message}"
           raiseSoftException(
-              method, "$tag: ReactInstance task faulted. $stageLabel. $faultLabel. $reasonLabel")
+              method,
+              "$tag: ReactInstance task faulted. $stageLabel. $faultLabel. $reasonLabel",
+          )
           return@unwrap currentReactInstance
         }
 
         if (task.isCancelled()) {
           raiseSoftException(
-              method, "$tag: ReactInstance task cancelled. $stageLabel. $reasonLabel")
+              method,
+              "$tag: ReactInstance task cancelled. $stageLabel. $reasonLabel",
+          )
           return@unwrap currentReactInstance
         }
 
         if (reactInstance == null) {
           raiseSoftException(
-              method, "$tag: ReactInstance task returned null. $stageLabel. $reasonLabel")
+              method,
+              "$tag: ReactInstance task returned null. $stageLabel. $reasonLabel",
+          )
           return@unwrap currentReactInstance
         }
 
         if (currentReactInstance != null && reactInstance != currentReactInstance) {
           raiseSoftException(
               method,
-              ("$tag: Detected two different ReactInstances. Returning old. $stageLabel. $reasonLabel"))
+              ("$tag: Detected two different ReactInstances. Returning old. $stageLabel. $reasonLabel"),
+          )
         }
         reactInstance
       }
@@ -1190,14 +1253,17 @@ public class ReactHostImpl(
                 raiseSoftException(method, "ReactContext is null. Reload reason: $reason")
               }
 
-              if (reactContext != null &&
-                  reactLifecycleStateManager.lifecycleState == LifecycleState.RESUMED) {
+              if (
+                  reactContext != null &&
+                      reactLifecycleStateManager.lifecycleState == LifecycleState.RESUMED
+              ) {
                 log(method, "Calling ReactContext.onHostPause()")
                 reactContext.onHostPause()
               }
               Task.forResult(reactInstance)
             },
-            uiExecutor)
+            uiExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               val reactInstance = taskUnwrapper(task, "2: Surface shutdown")
@@ -1208,7 +1274,8 @@ public class ReactHostImpl(
               }
               task
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               taskUnwrapper(task, "3: Destroying ReactContext")
@@ -1236,7 +1303,8 @@ public class ReactHostImpl(
               }
               task
             },
-            uiExecutor)
+            uiExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               val reactInstance = taskUnwrapper(task, "4: Destroying ReactInstance")
@@ -1256,7 +1324,8 @@ public class ReactHostImpl(
               // Kickstart a new ReactInstance create
               getOrCreateReactInstanceTask()
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               val reactInstance = taskUnwrapper(task, "5: Restarting surfaces")
@@ -1267,7 +1336,8 @@ public class ReactHostImpl(
               }
               task
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               if (task.isFaulted()) {
@@ -1275,19 +1345,22 @@ public class ReactHostImpl(
                 raiseSoftException(
                     method,
                     ("Error during reload. ReactInstance task faulted. Fault reason: ${fault.message}. Reload reason: $reason"),
-                    task.getError())
+                    task.getError(),
+                )
               }
               if (task.isCancelled()) {
                 raiseSoftException(
                     method,
-                    "Error during reload. ReactInstance task cancelled. Reload reason: $reason")
+                    "Error during reload. ReactInstance task cancelled. Reload reason: $reason",
+                )
               }
 
               log(method, "Resetting reload task ref")
               reloadTask = null
               task
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .also { reloadTask = it }
   }
 
@@ -1352,7 +1425,8 @@ public class ReactHostImpl(
               reactLifecycleStateManager.moveToOnHostDestroy(reactContext)
               Task.forResult<ReactInstance>(reactInstance)
             },
-            uiExecutor)
+            uiExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               val reactInstance = taskUnwrapper(task, "2: Stopping surfaces")
@@ -1365,7 +1439,8 @@ public class ReactHostImpl(
               }
               task
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               taskUnwrapper(task, "3: Destroying ReactContext")
@@ -1397,7 +1472,8 @@ public class ReactHostImpl(
               ResourceDrawableIdHelper.clear()
               task
             },
-            uiExecutor)
+            uiExecutor,
+        )
         .continueWithTask(
             { task: Task<ReactInstance> ->
               val reactInstance = taskUnwrapper(task, "4: Destroying ReactInstance")
@@ -1418,19 +1494,22 @@ public class ReactHostImpl(
               destroyTask = null
               task
             },
-            bgExecutor)
+            bgExecutor,
+        )
         .continueWith<Void>({ task: Task<ReactInstance> ->
           if (task.isFaulted()) {
             val fault = checkNotNull(task.getError())
             raiseSoftException(
                 method,
                 ("React destruction failed. ReactInstance task faulted. Fault reason: ${fault.message}. Destroy reason: $reason"),
-                task.getError())
+                task.getError(),
+            )
           }
           if (task.isCancelled()) {
             raiseSoftException(
                 method,
-                "React destruction failed. ReactInstance task cancelled. Destroy reason: $reason")
+                "React destruction failed. ReactInstance task cancelled. Destroy reason: $reason",
+            )
           }
           null
         })
@@ -1447,12 +1526,13 @@ public class ReactHostImpl(
   }
 
   @ThreadConfined(ThreadConfined.UI)
-  internal fun unregisterInstanceFromInspector(reactInstance: ReactInstance?): Unit {
+  internal fun unregisterInstanceFromInspector(reactInstance: ReactInstance?) {
     if (reactInstance != null) {
       if (InspectorFlags.getFuseboxEnabled()) {
         Assertions.assertCondition(
             reactHostInspectorTarget?.isValid() == true,
-            "Host inspector target destroyed before instance was unregistered")
+            "Host inspector target destroyed before instance was unregistered",
+        )
       }
       reactInstance.unregisterFromInspector()
     }