react-native-tvos 0.73.7-1 → 0.74.0-0

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

@@ -15,6 +15,9 @@ import static java.lang.Boolean.TRUE;
 
 import android.app.Activity;
 import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.nfc.NfcAdapter;
 import android.os.Bundle;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -29,6 +32,7 @@ import com.facebook.react.ReactHost;
 import com.facebook.react.ReactInstanceEventListener;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.JSBundleLoader;
+import com.facebook.react.bridge.JavaScriptContextHolder;
 import com.facebook.react.bridge.MemoryPressureListener;
 import com.facebook.react.bridge.NativeArray;
 import com.facebook.react.bridge.NativeModule;
@@ -38,6 +42,7 @@ 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;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.queue.QueueThreadExceptionHandler;
 import com.facebook.react.bridge.queue.ReactQueueConfiguration;
@@ -52,11 +57,13 @@ import com.facebook.react.fabric.FabricUIManager;
 import com.facebook.react.interfaces.TaskInterface;
 import com.facebook.react.interfaces.exceptionmanager.ReactJsExceptionHandler;
 import com.facebook.react.interfaces.fabric.ReactSurface;
+import com.facebook.react.modules.appearance.AppearanceModule;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.runtime.internal.bolts.Continuation;
 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.UIManagerModule;
 import com.facebook.react.uimanager.events.BlackHoleEventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -67,7 +74,6 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
-import java.util.concurrent.Callable;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -201,11 +207,7 @@ public class ReactHostImpl implements ReactHost {
    */
   @Override
   public TaskInterface<Void> start() {
-    if (ReactFeatureFlags.enableBridgelessArchitectureNewCreateReloadDestroy) {
-      return newStart();
-    }
-
-    return oldStart();
+    return Task.call(this::getOrCreateStartTask, mBGExecutor).continueWithTask(Task::getResult);
   }
 
   /** Initialize and run a React Native surface in a background without mounting real views. */
@@ -440,36 +442,32 @@ public class ReactHostImpl implements ReactHost {
   @Override
   public TaskInterface<Void> reload(String reason) {
     final String method = "reload()";
-    if (ReactFeatureFlags.enableBridgelessArchitectureNewCreateReloadDestroy) {
-      return Task.call(
-              () -> {
-                Task<Void> reloadTask = null;
-                if (mDestroyTask != null) {
-                  log(method, "Waiting for destroy to finish, before reloading React Native.");
-                  reloadTask =
-                      mDestroyTask
-                          .continueWithTask(task -> newGetOrCreateReloadTask(reason), mBGExecutor)
-                          .makeVoid();
-                } else {
-                  reloadTask = newGetOrCreateReloadTask(reason).makeVoid();
-                }
-
-                return reloadTask.continueWithTask(
-                    task -> {
-                      if (task.isFaulted()) {
-                        mReactHostDelegate.handleInstanceException(task.getError());
-                        return newGetOrCreateDestroyTask("Reload failed", task.getError());
-                      }
+    return Task.call(
+            () -> {
+              Task<Void> reloadTask = null;
+              if (mDestroyTask != null) {
+                log(method, "Waiting for destroy to finish, before reloading React Native.");
+                reloadTask =
+                    mDestroyTask
+                        .continueWithTask(task -> getOrCreateReloadTask(reason), mBGExecutor)
+                        .makeVoid();
+              } else {
+                reloadTask = getOrCreateReloadTask(reason).makeVoid();
+              }
 
-                      return task;
-                    },
-                    mBGExecutor);
-              },
-              mBGExecutor)
-          .continueWithTask(Task::getResult);
-    }
+              return reloadTask.continueWithTask(
+                  task -> {
+                    if (task.isFaulted()) {
+                      mReactHostDelegate.handleInstanceException(task.getError());
+                      return getOrCreateDestroyTask("Reload failed", task.getError());
+                    }
 
-    return oldReload(reason);
+                    return task;
+                  },
+                  mBGExecutor);
+            },
+            mBGExecutor)
+        .continueWithTask(Task::getResult);
   }
 
   /**
@@ -485,24 +483,19 @@ public class ReactHostImpl implements ReactHost {
   @Override
   public TaskInterface<Void> destroy(String reason, @Nullable Exception ex) {
     final String method = "destroy()";
-    if (ReactFeatureFlags.enableBridgelessArchitectureNewCreateReloadDestroy) {
-      return Task.call(
-              () -> {
-                if (mReloadTask != null) {
-                  log(
-                      method,
-                      "Reloading React Native. Waiting for reload to finish before destroying React Native.");
-                  return mReloadTask.continueWithTask(
-                      task -> newGetOrCreateDestroyTask(reason, ex), mBGExecutor);
-                }
-                return newGetOrCreateDestroyTask(reason, ex);
-              },
-              mBGExecutor)
-          .continueWithTask(Task::getResult);
-    }
-
-    oldDestroy(reason, ex);
-    return Task.forResult(nullsafeFIXME(null, "Empty Destroy Task"));
+    return Task.call(
+            () -> {
+              if (mReloadTask != null) {
+                log(
+                    method,
+                    "Reloading React Native. Waiting for reload to finish before destroying React Native.");
+                return mReloadTask.continueWithTask(
+                    task -> getOrCreateDestroyTask(reason, ex), mBGExecutor);
+              }
+              return getOrCreateDestroyTask(reason, ex);
+            },
+            mBGExecutor)
+        .continueWithTask(Task::getResult);
   }
 
   private MemoryPressureListener createMemoryPressureListener(ReactInstance reactInstance) {
@@ -556,7 +549,8 @@ public class ReactHostImpl implements ReactHost {
     return reactInstance.getEventDispatcher();
   }
 
-  /* package */ @Nullable
+  /* package */
+  @Nullable
   FabricUIManager getUIManager() {
     final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
     if (reactInstance == null) {
@@ -581,7 +575,8 @@ public class ReactHostImpl implements ReactHost {
     return new ArrayList<>();
   }
 
-  /* package */ @Nullable
+  /* package */
+  @Nullable
   <T extends NativeModule> T getNativeModule(Class<T> nativeModuleInterface) {
     if (nativeModuleInterface == UIManagerModule.class) {
       ReactSoftExceptionLogger.logSoftExceptionVerbose(
@@ -597,6 +592,134 @@ public class ReactHostImpl implements ReactHost {
     return null;
   }
 
+  /* package */
+  @Nullable
+  RuntimeExecutor getRuntimeExecutor() {
+    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    if (reactInstance != null) {
+      return reactInstance.getBufferedRuntimeExecutor();
+    }
+    ReactSoftExceptionLogger.logSoftException(
+        TAG,
+        new ReactNoCrashSoftException("Tried to get runtime executor while instance is not ready"));
+    return null;
+  }
+
+  /* package */
+  @Nullable
+  CallInvokerHolder getJSCallInvokerHolder() {
+    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    if (reactInstance != null) {
+      return reactInstance.getJSCallInvokerHolder();
+    }
+    ReactSoftExceptionLogger.logSoftException(
+        TAG,
+        new ReactNoCrashSoftException(
+            "Tried to get JSCallInvokerHolder while instance is not ready"));
+    return null;
+  }
+
+  /**
+   * To be called when the host activity receives an activity result.
+   *
+   * @param activity The host activity
+   */
+  @ThreadConfined(UI)
+  @Override
+  public void onActivityResult(
+      Activity activity, int requestCode, int resultCode, @Nullable Intent data) {
+    final String method =
+        "onActivityResult(activity = \""
+            + activity
+            + "\", requestCode = \""
+            + requestCode
+            + "\", resultCode = \""
+            + resultCode
+            + "\", data = \""
+            + data
+            + "\")";
+    log(method);
+
+    ReactContext currentContext = getCurrentReactContext();
+    if (currentContext != null) {
+      currentContext.onActivityResult(activity, requestCode, resultCode, data);
+    }
+    ReactSoftExceptionLogger.logSoftException(
+        TAG,
+        new ReactNoCrashSoftException(
+            "Tried to access onActivityResult while context is not ready"));
+  }
+
+  /* To be called when focus has changed for the hosting window. */
+  @ThreadConfined(UI)
+  @Override
+  public void onWindowFocusChange(boolean hasFocus) {
+    final String method = "onWindowFocusChange(hasFocus = \"" + hasFocus + "\")";
+    log(method);
+
+    ReactContext currentContext = getCurrentReactContext();
+    if (currentContext != null) {
+      currentContext.onWindowFocusChange(hasFocus);
+    }
+    ReactSoftExceptionLogger.logSoftException(
+        TAG,
+        new ReactNoCrashSoftException(
+            "Tried to access onWindowFocusChange while context is not ready"));
+  }
+
+  /* This method will give JS the opportunity to receive intents via Linking.
+   *
+   * @param intent The incoming intent
+   */
+  @ThreadConfined(UI)
+  @Override
+  public void onNewIntent(Intent intent) {
+    log("onNewIntent()");
+
+    ReactContext currentContext = getCurrentReactContext();
+    if (currentContext != null) {
+      String action = intent.getAction();
+      Uri uri = intent.getData();
+
+      if (uri != null
+          && (Intent.ACTION_VIEW.equals(action)
+              || NfcAdapter.ACTION_NDEF_DISCOVERED.equals(action))) {
+        DeviceEventManagerModule deviceEventManagerModule =
+            currentContext.getNativeModule(DeviceEventManagerModule.class);
+        if (deviceEventManagerModule != null) {
+          deviceEventManagerModule.emitNewIntentReceived(uri);
+        }
+      }
+      currentContext.onNewIntent(getCurrentActivity(), intent);
+    }
+    ReactSoftExceptionLogger.logSoftException(
+        TAG,
+        new ReactNoCrashSoftException("Tried to access onNewIntent while context is not ready"));
+  }
+
+  @ThreadConfined(UI)
+  @Override
+  public void onConfigurationChanged(Context updatedContext) {
+    ReactContext currentReactContext = getCurrentReactContext();
+    if (currentReactContext != null) {
+      AppearanceModule appearanceModule =
+          currentReactContext.getNativeModule(AppearanceModule.class);
+
+      if (appearanceModule != null) {
+        appearanceModule.onConfigurationChanged(updatedContext);
+      }
+    }
+  }
+
+  @Nullable
+  JavaScriptContextHolder getJavaScriptContextHolder() {
+    final ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
+    if (reactInstance != null) {
+      return reactInstance.getJavaScriptContextHolder();
+    }
+    return null;
+  }
+
   /* package */
   DefaultHardwareBackBtnHandler getDefaultBackButtonHandler() {
     return () -> {
@@ -719,61 +842,29 @@ public class ReactHostImpl implements ReactHost {
   @ThreadConfined("ReactHost")
   private @Nullable Task<Void> mStartTask = null;
 
-  private Task<Void> oldStart() {
-    final String method = "oldStart()";
-    return Task.call(
-            () -> {
-              if (mStartTask == null) {
-                log(method, "Schedule");
-                mStartTask =
-                    getOrCreateReactInstanceTask()
-                        .continueWithTask(
-                            task -> {
-                              if (task.isFaulted()) {
-                                destroy(
-                                    "oldStart() failure: " + task.getError().getMessage(),
-                                    task.getError());
-                                mReactHostDelegate.handleInstanceException(task.getError());
-                              }
-
-                              return task;
-                            },
-                            mBGExecutor)
-                        .makeVoid();
-              }
-              return mStartTask;
-            },
-            mBGExecutor)
-        .continueWithTask(Task::getResult);
-  }
-
-  private Task<Void> newStart() {
-    final String method = "newStart()";
-    return Task.call(
-            () -> {
-              if (mStartTask == null) {
-                log(method, "Schedule");
-                mStartTask =
-                    waitThenCallNewGetOrCreateReactInstanceTask()
-                        .continueWithTask(
-                            (task) -> {
-                              if (task.isFaulted()) {
-                                mReactHostDelegate.handleInstanceException(task.getError());
-                                // Wait for destroy to finish
-                                return newGetOrCreateDestroyTask(
-                                        "newStart() failure: " + task.getError().getMessage(),
-                                        task.getError())
-                                    .continueWithTask(destroyTask -> Task.forError(task.getError()))
-                                    .makeVoid();
-                              }
-                              return task.makeVoid();
-                            },
-                            mBGExecutor);
-              }
-              return mStartTask;
-            },
-            mBGExecutor)
-        .continueWithTask(Task::getResult);
+  @ThreadConfined("ReactHost")
+  private Task<Void> getOrCreateStartTask() {
+    final String method = "getOrCreateStartTask()";
+    if (mStartTask == null) {
+      log(method, "Schedule");
+      mStartTask =
+          waitThenCallGetOrCreateReactInstanceTask()
+              .continueWithTask(
+                  (task) -> {
+                    if (task.isFaulted()) {
+                      mReactHostDelegate.handleInstanceException(task.getError());
+                      // Wait for destroy to finish
+                      return getOrCreateDestroyTask(
+                              "getOrCreateStartTask() failure: " + task.getError().getMessage(),
+                              task.getError())
+                          .continueWithTask(destroyTask -> Task.forError(task.getError()))
+                          .makeVoid();
+                    }
+                    return task.makeVoid();
+                  },
+                  mBGExecutor);
+    }
+    return mStartTask;
   }
 
   @ThreadConfined(UI)
@@ -824,7 +915,7 @@ public class ReactHostImpl implements ReactHost {
       final String callingMethod, final VeniceThenable<ReactInstance> runnable) {
     final String method = "callAfterGetOrCreateReactInstance(" + callingMethod + ")";
 
-    return getOrCreateReactInstanceTask()
+    return getOrCreateReactInstance()
         .onSuccess(
             (Continuation<ReactInstance, Void>)
                 task -> {
@@ -863,24 +954,20 @@ public class ReactHostImpl implements ReactHost {
    * <p>If the ReactInstance is reloading, will return the reload task. If the ReactInstance is
    * destroying, will wait until destroy is finished, before creating.
    */
-  private Task<ReactInstance> getOrCreateReactInstanceTask() {
-    if (ReactFeatureFlags.enableBridgelessArchitectureNewCreateReloadDestroy) {
-      return Task.call(this::waitThenCallNewGetOrCreateReactInstanceTask, mBGExecutor)
-          .continueWithTask(Task::getResult);
-    }
-
-    return oldGetOrCreateReactInstanceTask();
+  private Task<ReactInstance> getOrCreateReactInstance() {
+    return Task.call(this::waitThenCallGetOrCreateReactInstanceTask, mBGExecutor)
+        .continueWithTask(Task::getResult);
   }
 
   @ThreadConfined("ReactHost")
-  private Task<ReactInstance> waitThenCallNewGetOrCreateReactInstanceTask() {
-    return waitThenCallNewGetOrCreateReactInstanceTaskWithRetries(0, 4);
+  private Task<ReactInstance> waitThenCallGetOrCreateReactInstanceTask() {
+    return waitThenCallGetOrCreateReactInstanceTaskWithRetries(0, 4);
   }
 
   @ThreadConfined("ReactHost")
-  private Task<ReactInstance> waitThenCallNewGetOrCreateReactInstanceTaskWithRetries(
+  private Task<ReactInstance> waitThenCallGetOrCreateReactInstanceTaskWithRetries(
       int tryNum, int maxTries) {
-    final String method = "waitThenCallNewGetOrCreateReactInstanceTaskWithRetries";
+    final String method = "waitThenCallGetOrCreateReactInstanceTaskWithRetries";
     if (mReloadTask != null) {
       log(method, "React Native is reloading. Return reload task.");
       return mReloadTask;
@@ -896,7 +983,7 @@ public class ReactHostImpl implements ReactHost {
                 + tryNum
                 + ").");
         return mDestroyTask.onSuccessTask(
-            (task) -> waitThenCallNewGetOrCreateReactInstanceTaskWithRetries(tryNum + 1, maxTries),
+            (task) -> waitThenCallGetOrCreateReactInstanceTaskWithRetries(tryNum + 1, maxTries),
             mBGExecutor);
       }
 
@@ -905,12 +992,12 @@ public class ReactHostImpl implements ReactHost {
           "React Native is tearing down. Not wait for teardown to finish: reached max retries.");
     }
 
-    return newGetOrCreateReactInstanceTask();
+    return getOrCreateReactInstanceTask();
   }
 
   @ThreadConfined("ReactHost")
-  private Task<ReactInstance> newGetOrCreateReactInstanceTask() {
-    final String method = "newGetOrCreateReactInstanceTask()";
+  private Task<ReactInstance> getOrCreateReactInstanceTask() {
+    final String method = "getOrCreateReactInstanceTask()";
     log(method);
 
     return mReactInstanceTaskRef.getOrCreate(
@@ -1028,87 +1115,6 @@ public class ReactHostImpl implements ReactHost {
         });
   }
 
-  private Task<ReactInstance> oldGetOrCreateReactInstanceTask() {
-    final String method = "oldGetOrCreateReactInstanceTask()";
-    log(method);
-
-    return mReactInstanceTaskRef.getOrCreate(
-        () -> {
-          log(method, "Start");
-          ReactMarker.logMarker(
-              ReactMarkerConstants.REACT_BRIDGELESS_LOADING_START, BRIDGELESS_MARKER_INSTANCE_KEY);
-
-          final BridgelessReactContext reactContext = getOrCreateReactContext();
-          final DevSupportManager devSupportManager = getDevSupportManager();
-          reactContext.setJSExceptionHandler(devSupportManager);
-
-          return getJsBundleLoader()
-              .onSuccess(
-                  task -> {
-                    final JSBundleLoader bundleLoader = task.getResult();
-                    log(method, "Creating ReactInstance");
-                    final ReactInstance instance =
-                        new ReactInstance(
-                            reactContext,
-                            mReactHostDelegate,
-                            mComponentFactory,
-                            devSupportManager,
-                            mQueueThreadExceptionHandler,
-                            mReactJsExceptionHandler,
-                            mUseDevSupport);
-
-                    if (ReactFeatureFlags
-                        .unstable_bridgelessArchitectureMemoryPressureHackyBoltsFix) {
-                      mMemoryPressureListener = createMemoryPressureListener(instance);
-                    }
-                    mMemoryPressureRouter.addMemoryPressureListener(mMemoryPressureListener);
-
-                    log(method, "Loading JS Bundle");
-                    instance.loadJSBundle(bundleLoader);
-
-                    log(
-                        method,
-                        "Calling DevSupportManagerBase.onNewReactContextCreated(reactContext)");
-                    devSupportManager.onNewReactContextCreated(reactContext);
-                    reactContext.runOnJSQueueThread(
-                        () -> {
-                          // Executing on the JS thread to ensurethat we're done
-                          // loading the JS bundle.
-                          // TODO T76081936 Move this if we switchto a sync RTE
-                          ReactMarker.logMarker(
-                              ReactMarkerConstants.REACT_BRIDGELESS_LOADING_END,
-                              BRIDGELESS_MARKER_INSTANCE_KEY);
-                        });
-                    return instance;
-                  },
-                  mBGExecutor)
-              .onSuccess(
-                  task -> {
-                    /*
-                     Call ReactContext.onHostResume() only when already in the resumed state which
-                     aligns with the bridge https://fburl.com/diffusion/2qhxmudv.
-                    */
-                    mReactLifecycleStateManager.resumeReactContextIfHostResumed(
-                        reactContext, getCurrentActivity());
-
-                    ReactInstanceEventListener[] listeners =
-                        new ReactInstanceEventListener[mReactInstanceEventListeners.size()];
-                    final ReactInstanceEventListener[] finalListeners =
-                        mReactInstanceEventListeners.toArray(listeners);
-
-                    log(method, "Executing ReactInstanceEventListeners");
-                    for (ReactInstanceEventListener listener : finalListeners) {
-                      if (listener != null) {
-                        listener.onReactContextInitialized(reactContext);
-                      }
-                    }
-
-                    return task.getResult();
-                  },
-                  mUIExecutor);
-        });
-  }
-
   private Task<JSBundleLoader> getJsBundleLoader() {
     final String method = "getJSBundleLoader()";
     log(method);
@@ -1281,8 +1287,8 @@ public class ReactHostImpl implements ReactHost {
    * ReactInstance task work throws an exception.
    */
   @ThreadConfined("ReactHost")
-  private Task<ReactInstance> newGetOrCreateReloadTask(String reason) {
-    final String method = "newGetOrCreateReloadTask()";
+  private Task<ReactInstance> getOrCreateReloadTask(String reason) {
+    final String method = "getOrCreateReloadTask()";
     log(method);
 
     // Log how React Native is destroyed
@@ -1393,7 +1399,7 @@ public class ReactHostImpl implements ReactHost {
                     mStartTask = null;
 
                     // Kickstart a new ReactInstance create
-                    return newGetOrCreateReactInstanceTask();
+                    return getOrCreateReactInstanceTask();
                   },
                   mBGExecutor)
               .continueWithTask(
@@ -1453,8 +1459,8 @@ public class ReactHostImpl implements ReactHost {
    * ReactInstance task work throws an exception.
    */
   @ThreadConfined("ReactHost")
-  private Task<Void> newGetOrCreateDestroyTask(final String reason, @Nullable Exception ex) {
-    final String method = "newGetOrCreateDestroyTask()";
+  private Task<Void> getOrCreateDestroyTask(final String reason, @Nullable Exception ex) {
+    final String method = "getOrCreateDestroyTask()";
     log(method);
 
     // Log how React Native is destroyed
@@ -1611,147 +1617,15 @@ public class ReactHostImpl implements ReactHost {
     return mDestroyTask;
   }
 
-  /** Destroy and recreate the ReactInstance and context. */
-  private Task<Void> oldReload(String reason) {
-    final String method = "oldReload()";
-    log(method);
-
-    // Log how React Native is destroyed
-    // TODO(T136397487): Remove after Venice is shipped to 100%
-    raiseSoftException(method, reason);
-
-    synchronized (mReactInstanceTaskRef) {
-      mMemoryPressureRouter.removeMemoryPressureListener(mMemoryPressureListener);
-      oldDestroyReactInstanceAndContext(method, reason);
-
-      return callAfterGetOrCreateReactInstance(
-          method,
-          reactInstance -> {
-            // Restart any attached surfaces
-            log(method, "Restarting Surfaces");
-            synchronized (mAttachedSurfaces) {
-              for (ReactSurfaceImpl surface : mAttachedSurfaces) {
-                reactInstance.startSurface(surface);
-              }
-            }
-          });
-    }
-  }
-
-  /** Destroy the specified instance and context. */
-  private void oldDestroy(String reason, @Nullable Exception ex) {
-    final String method = "oldDestroy()";
-    log(method);
-
-    // Log how React Native is destroyed
-    // TODO(T136397487): Remove after Venice is shipped to 100%
-    raiseSoftException(method, reason, ex);
-
-    synchronized (mReactInstanceTaskRef) {
-      // Prevent re-destroy when ReactInstance has been reset already, which could happen when
-      // calling destroy multiple times on the same thread
-      ReactInstance reactInstance = mReactInstanceTaskRef.get().getResult();
-      if (reactInstance == null) {
-        return;
-      }
-
-      // Retain a reference to current ReactContext before de-referenced by mReactContextRef
-      final ReactContext reactContext = getCurrentReactContext();
-
-      if (reactContext != null) {
-        mMemoryPressureRouter.destroy(reactContext);
-      }
-
-      oldDestroyReactInstanceAndContext(method, reason);
-
-      // Remove all attached surfaces
-      log(method, "Clearing attached surfaces");
-      synchronized (mAttachedSurfaces) {
-        mAttachedSurfaces.clear();
-      }
-
-      Task.call(
-          (Callable<Void>)
-              () -> {
-                moveToHostDestroy(reactContext);
-                return null;
-              },
-          mUIExecutor);
-    }
-  }
-
-  private void oldDestroyReactInstanceAndContext(final String callingMethod, final String reason) {
-    final String method = "oldDestroyReactInstanceAndContext(" + callingMethod + ")";
-    log(method);
-
-    synchronized (mReactInstanceTaskRef) {
-      Task<ReactInstance> task = mReactInstanceTaskRef.getAndReset();
-      if (!task.isFaulted() && !task.isCancelled()) {
-        final ReactInstance instance = task.getResult();
-
-        // Noop on redundant calls to destroyReactInstance()
-        if (instance == null) {
-          log(method, "ReactInstance is null");
-          return;
-        }
-
-        /*
-         * The surfaces should be stopped before the instance destroy.
-         * Calling stop directly on instance ensures we keep the list of attached surfaces for restart.
-         */
-        log(method, "Stopping surfaces");
-        synchronized (mAttachedSurfaces) {
-          for (ReactSurfaceImpl surface : mAttachedSurfaces) {
-            instance.stopSurface(surface);
-            surface.clear();
-          }
-        }
-
-        ReactContext reactContext = getCurrentReactContext();
-
-        // Reset the ReactContext inside the DevSupportManager
-        if (reactContext != null) {
-          log(method, "DevSupportManager.onReactInstanceDestroyed()");
-          getDevSupportManager().onReactInstanceDestroyed(reactContext);
-          log(method, "Destroy ReactContext");
-          mBridgelessReactContextRef.reset();
-        }
-
-        mBGExecutor.execute(
-            () -> {
-              // instance.destroy() is time consuming and is confined to ReactHost thread.
-              log(method, "Destroy ReactInstance");
-              instance.destroy();
-
-              // Re-enable preloads
-              log(method, "Resetting Preload task ref");
-              mStartTask = null;
-            });
-      } else {
-        raiseSoftException(
-            method,
-            ("Not cleaning up ReactInstance: task.isFaulted() = "
-                    + task.isFaulted()
-                    + ", task.isCancelled() = "
-                    + task.isCancelled())
-                + ". Reason: "
-                + reason);
-
-        mBGExecutor.execute(
-            () -> {
-              log(method, "Resetting Preload task ref");
-              mStartTask = null;
-            });
-      }
-    }
+  @Nullable
+  @Override
+  public JSEngineResolutionAlgorithm getJsEngineResolutionAlgorithm() {
+    return mJSEngineResolutionAlgorithm;
   }
 
-  public void setJSEngineResolutionAlgorithm(
+  @Override
+  public void setJsEngineResolutionAlgorithm(
       @Nullable JSEngineResolutionAlgorithm jsEngineResolutionAlgorithm) {
     mJSEngineResolutionAlgorithm = jsEngineResolutionAlgorithm;
   }
-
-  public @Nullable JSEngineResolutionAlgorithm getJSEngineResolutionAlgorithm() {
-    return mJSEngineResolutionAlgorithm;
-  }
 }