react-native 0.66.0-rc.4 → 0.67.0-rc.1

package/ReactAndroid/src/main/java/com/facebook/react/ReactActivity.java

@@ -8,6 +8,7 @@
 package com.facebook.react;
 
 import android.content.Intent;
+import android.content.res.Configuration;
 import android.os.Bundle;
 import android.view.KeyEvent;
 import androidx.annotation.Nullable;
@@ -121,6 +122,12 @@ public abstract class ReactActivity extends AppCompatActivity
     mDelegate.onWindowFocusChanged(hasFocus);
   }
 
+  @Override
+  public void onConfigurationChanged(Configuration newConfig) {
+    super.onConfigurationChanged(newConfig);
+    mDelegate.onConfigurationChanged(newConfig);
+  }
+
   protected final ReactNativeHost getReactNativeHost() {
     return mDelegate.getReactNativeHost();
   }

package/ReactAndroid/src/main/java/com/facebook/react/ReactActivityDelegate.java

@@ -11,6 +11,7 @@ import android.annotation.TargetApi;
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
+import android.content.res.Configuration;
 import android.os.Build;
 import android.os.Bundle;
 import android.view.KeyEvent;
@@ -154,6 +155,12 @@ public class ReactActivityDelegate {
     }
   }
 
+  public void onConfigurationChanged(Configuration newConfig) {
+    if (getReactNativeHost().hasInstance()) {
+      getReactInstanceManager().onConfigurationChanged(getContext(), newConfig);
+    }
+  }
+
   @TargetApi(Build.VERSION_CODES.M)
   public void requestPermissions(
       String[] permissions, int requestCode, PermissionListener listener) {

package/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java

@@ -65,6 +65,7 @@ import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
 import com.facebook.react.bridge.ProxyJavaScriptExecutor;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactCxxErrorHandler;
 import com.facebook.react.bridge.ReactMarker;
 import com.facebook.react.bridge.ReactMarkerConstants;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
@@ -75,6 +76,7 @@ import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.bridge.queue.ReactQueueConfigurationSpec;
 import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.SurfaceDelegateFactory;
 import com.facebook.react.common.annotations.VisibleForTesting;
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
@@ -91,7 +93,6 @@ import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.modules.debug.interfaces.DeveloperSettings;
 import com.facebook.react.modules.fabric.ReactFabric;
 import com.facebook.react.packagerconnection.RequestHandler;
-import com.facebook.react.runtimescheduler.RuntimeSchedulerManager;
 import com.facebook.react.surface.ReactStage;
 import com.facebook.react.turbomodule.core.TurboModuleManager;
 import com.facebook.react.turbomodule.core.TurboModuleManagerDelegate;
@@ -107,6 +108,7 @@ import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
 import com.facebook.soloader.SoLoader;
 import com.facebook.systrace.Systrace;
 import com.facebook.systrace.SystraceMessage;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -156,14 +158,15 @@ public class ReactInstanceManager {
   /* accessed from any thread */
   private final JavaScriptExecutorFactory mJavaScriptExecutorFactory;
 
+  // See {@code ReactInstanceManagerBuilder} for description of all flags here.
   private @Nullable List<String> mViewManagerNames = null;
   private final @Nullable JSBundleLoader mBundleLoader;
   private final @Nullable String mJSMainModulePath; /* path to JS bundle root on Metro */
   private final List<ReactPackage> mPackages;
   private final DevSupportManager mDevSupportManager;
   private final boolean mUseDeveloperSupport;
+  private final boolean mRequireActivity;
   private @Nullable ComponentNameResolverManager mComponentNameResolverManager;
-  private @Nullable RuntimeSchedulerManager mRuntimeSchedulerManager;
   private final @Nullable NotThreadSafeBridgeIdleDebugListener mBridgeIdleDebugListener;
   private final Object mReactContextLock = new Object();
   private @Nullable volatile ReactContext mCurrentReactContext;
@@ -182,6 +185,7 @@ public class ReactInstanceManager {
   private final @Nullable JSIModulePackage mJSIModulePackage;
   private final @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
   private List<ViewManager> mViewManagers;
+  private boolean mUseFallbackBundle = false;
 
   private class ReactContextInitParams {
     private final JavaScriptExecutorFactory mJsExecutorFactory;
@@ -216,6 +220,8 @@ public class ReactInstanceManager {
       @Nullable String jsMainModulePath,
       List<ReactPackage> packages,
       boolean useDeveloperSupport,
+      DevSupportManagerFactory devSupportManagerFactory,
+      boolean requireActivity,
       @Nullable NotThreadSafeBridgeIdleDebugListener bridgeIdleDebugListener,
       LifecycleState initialLifecycleState,
       @Nullable UIImplementationProvider mUIImplementationProvider,
@@ -227,12 +233,14 @@ public class ReactInstanceManager {
       int minTimeLeftInFrameForNonBatchedOperationMs,
       @Nullable JSIModulePackage jsiModulePackage,
       @Nullable Map<String, RequestHandler> customPackagerCommandHandlers,
-      @Nullable ReactPackageTurboModuleManagerDelegate.Builder tmmDelegateBuilder) {
+      @Nullable ReactPackageTurboModuleManagerDelegate.Builder tmmDelegateBuilder,
+      @Nullable SurfaceDelegateFactory surfaceDelegateFactory) {
     FLog.d(TAG, "ReactInstanceManager.ctor()");
     initializeSoLoaderIfNecessary(applicationContext);
 
     DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(applicationContext);
 
+    // See {@code ReactInstanceManagerBuilder} for description of all flags here.
     mApplicationContext = applicationContext;
     mCurrentActivity = currentActivity;
     mDefaultBackButtonImpl = defaultHardwareBackBtnHandler;
@@ -241,10 +249,11 @@ public class ReactInstanceManager {
     mJSMainModulePath = jsMainModulePath;
     mPackages = new ArrayList<>();
     mUseDeveloperSupport = useDeveloperSupport;
+    mRequireActivity = requireActivity;
     Systrace.beginSection(
         Systrace.TRACE_TAG_REACT_JAVA_BRIDGE, "ReactInstanceManager.initDevSupportManager");
     mDevSupportManager =
-        DevSupportManagerFactory.create(
+        devSupportManagerFactory.create(
             applicationContext,
             createDevHelperInterface(),
             mJSMainModulePath,
@@ -252,7 +261,8 @@ public class ReactInstanceManager {
             redBoxHandler,
             devBundleDownloadListener,
             minNumShakes,
-            customPackagerCommandHandlers);
+            customPackagerCommandHandlers,
+            surfaceDelegateFactory);
     Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
     mBridgeIdleDebugListener = bridgeIdleDebugListener;
     mLifecycleState = initialLifecycleState;
@@ -286,6 +296,8 @@ public class ReactInstanceManager {
     if (mUseDeveloperSupport) {
       mDevSupportManager.startInspector();
     }
+
+    registerCxxErrorHandlerFunc();
   }
 
   private ReactInstanceDevHelper createDevHelperInterface() {
@@ -343,6 +355,10 @@ public class ReactInstanceManager {
     };
   }
 
+  public synchronized void setUseFallbackBundle(boolean useFallbackBundle) {
+    mUseFallbackBundle = useFallbackBundle;
+  }
+
   private JavaScriptExecutorFactory getJSExecutorFactory() {
     return mJavaScriptExecutorFactory;
   }
@@ -359,6 +375,22 @@ public class ReactInstanceManager {
     return new ArrayList<>(mPackages);
   }
 
+  public void handleCxxError(Exception e) {
+    mDevSupportManager.handleException(e);
+  }
+
+  public void registerCxxErrorHandlerFunc() {
+    Class[] parameterTypes = new Class[1];
+    parameterTypes[0] = Exception.class;
+    Method handleCxxErrorFunc = null;
+    try {
+      handleCxxErrorFunc = ReactInstanceManager.class.getMethod("handleCxxError", parameterTypes);
+    } catch (NoSuchMethodException e) {
+      FLog.e("ReactInstanceHolder", "Failed to set cxx error hanlder function", e);
+    }
+    ReactCxxErrorHandler.setHandleErrorFunc(this, handleCxxErrorFunc);
+  }
+
   static void initializeSoLoaderIfNecessary(Context applicationContext) {
     // Call SoLoader.initialize here, this is required for apps that does not use exopackage and
     // does not use SoLoader for loading other native code except from the one used by React Native
@@ -429,7 +461,8 @@ public class ReactInstanceManager {
                           if (packagerIsRunning) {
                             mDevSupportManager.handleReloadJS();
                           } else if (mDevSupportManager.hasUpToDateJSBundleInCache()
-                              && !devSettings.isRemoteJSDebugEnabled()) {
+                              && !devSettings.isRemoteJSDebugEnabled()
+                              && !mUseFallbackBundle) {
                             // If there is a up-to-date bundle downloaded from server,
                             // with remote JS debugging disabled, always use that.
                             onJSBundleLoadedFromServer();
@@ -558,16 +591,20 @@ public class ReactInstanceManager {
    * @param activity the activity being paused
    */
   @ThreadConfined(UI)
-  public void onHostPause(Activity activity) {
-    Assertions.assertNotNull(mCurrentActivity);
-    Assertions.assertCondition(
-        activity == mCurrentActivity,
-        "Pausing an activity that is not the current activity, this is incorrect! "
-            + "Current activity: "
-            + mCurrentActivity.getClass().getSimpleName()
-            + " "
-            + "Paused activity: "
-            + activity.getClass().getSimpleName());
+  public void onHostPause(@Nullable Activity activity) {
+    if (mRequireActivity) {
+      Assertions.assertCondition(mCurrentActivity != null);
+    }
+    if (mCurrentActivity != null) {
+      Assertions.assertCondition(
+          activity == mCurrentActivity,
+          "Pausing an activity that is not the current activity, this is incorrect! "
+              + "Current activity: "
+              + mCurrentActivity.getClass().getSimpleName()
+              + " "
+              + "Paused activity: "
+              + activity.getClass().getSimpleName());
+    }
     onHostPause();
   }
 
@@ -583,7 +620,8 @@ public class ReactInstanceManager {
    *     this instance of {@link ReactInstanceManager}.
    */
   @ThreadConfined(UI)
-  public void onHostResume(Activity activity, DefaultHardwareBackBtnHandler defaultBackButtonImpl) {
+  public void onHostResume(
+      @Nullable Activity activity, DefaultHardwareBackBtnHandler defaultBackButtonImpl) {
     UiThreadUtil.assertOnUiThread();
 
     mDefaultBackButtonImpl = defaultBackButtonImpl;
@@ -592,7 +630,7 @@ public class ReactInstanceManager {
 
   /** Use this method when the activity resumes. */
   @ThreadConfined(UI)
-  public void onHostResume(Activity activity) {
+  public void onHostResume(@Nullable Activity activity) {
     UiThreadUtil.assertOnUiThread();
 
     mCurrentActivity = activity;
@@ -631,8 +669,8 @@ public class ReactInstanceManager {
           // activity is attached to window, we can enable dev support immediately
           mDevSupportManager.setDevSupportEnabled(true);
         }
-      } else {
-        // there is no activity, we can enable dev support
+      } else if (!mRequireActivity) {
+        // there is no activity, but we can enable dev support
         mDevSupportManager.setDevSupportEnabled(true);
       }
     }
@@ -666,7 +704,9 @@ public class ReactInstanceManager {
    * @param activity the activity being destroyed
    */
   @ThreadConfined(UI)
-  public void onHostDestroy(Activity activity) {
+  public void onHostDestroy(@Nullable Activity activity) {
+    // In some cases, Activity may (correctly) be null.
+    // See mRequireActivity flag.
     if (activity == mCurrentActivity) {
       onHostDestroy();
     }
@@ -727,7 +767,6 @@ public class ReactInstanceManager {
       mViewManagerNames = null;
     }
     mComponentNameResolverManager = null;
-    mRuntimeSchedulerManager = null;
     FLog.d(ReactConstants.TAG, "ReactInstanceManager has been destroyed");
   }
 
@@ -1190,7 +1229,8 @@ public class ReactInstanceManager {
     // If we can't get a UIManager something has probably gone horribly wrong
     if (uiManager == null) {
       throw new IllegalStateException(
-          "Unable to attach a rootView to ReactInstance when UIManager is not properly initialized.");
+          "Unable to attach a rootView to ReactInstance when UIManager is not properly"
+              + " initialized.");
     }
 
     @Nullable Bundle initialProperties = reactRoot.getAppProperties();
@@ -1362,9 +1402,6 @@ public class ReactInstanceManager {
               });
       catalystInstance.setGlobalVariable("__fbStaticViewConfig", "true");
     }
-    if (ReactFeatureFlags.enableRuntimeScheduler) {
-      mRuntimeSchedulerManager = new RuntimeSchedulerManager(catalystInstance.getRuntimeExecutor());
-    }
 
     ReactMarker.logMarker(ReactMarkerConstants.PRE_RUN_JS_BUNDLE_START);
     Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "runJSBundle");

package/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerBuilder.java

@@ -22,6 +22,9 @@ import com.facebook.react.bridge.JavaScriptExecutorFactory;
 import com.facebook.react.bridge.NativeModuleCallExceptionHandler;
 import com.facebook.react.bridge.NotThreadSafeBridgeIdleDebugListener;
 import com.facebook.react.common.LifecycleState;
+import com.facebook.react.common.SurfaceDelegateFactory;
+import com.facebook.react.devsupport.DefaultDevSupportManagerFactory;
+import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.RedBoxHandler;
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
@@ -45,6 +48,8 @@ public class ReactInstanceManagerBuilder {
   private @Nullable NotThreadSafeBridgeIdleDebugListener mBridgeIdleDebugListener;
   private @Nullable Application mApplication;
   private boolean mUseDeveloperSupport;
+  private @Nullable DevSupportManagerFactory mDevSupportManagerFactory;
+  private boolean mRequireActivity;
   private @Nullable LifecycleState mInitialLifecycleState;
   private @Nullable UIImplementationProvider mUIImplementationProvider;
   private @Nullable NativeModuleCallExceptionHandler mNativeModuleCallExceptionHandler;
@@ -59,6 +64,7 @@ public class ReactInstanceManagerBuilder {
   private @Nullable JSIModulePackage mJSIModulesPackage;
   private @Nullable Map<String, RequestHandler> mCustomPackagerCommandHandlers;
   private @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
+  private @Nullable SurfaceDelegateFactory mSurfaceDelegateFactory;
 
   /* package protected */ ReactInstanceManagerBuilder() {}
 
@@ -171,6 +177,40 @@ public class ReactInstanceManagerBuilder {
     return this;
   }
 
+  /**
+   * Set the custom {@link DevSupportManagerFactory}. If not set, will use {@link
+   * DefaultDevSupportManagerFactory}.
+   */
+  public ReactInstanceManagerBuilder setDevSupportManagerFactory(
+      final DevSupportManagerFactory devSupportManagerFactory) {
+    mDevSupportManagerFactory = devSupportManagerFactory;
+    return this;
+  }
+
+  /**
+   * When {@code false}, indicates that correct usage of React Native will NOT involve an Activity.
+   * For the vast majority of Android apps in the ecosystem, this will not need to change. Unless
+   * you really know what you're doing, you should probably not change this!
+   */
+  public ReactInstanceManagerBuilder setRequireActivity(boolean requireActivity) {
+    mRequireActivity = requireActivity;
+    return this;
+  }
+
+  /**
+   * When the {@link SurfaceDelegateFactory} is provided, it will be used for native modules to get
+   * a {@link SurfaceDelegate} to interact with the platform specific surface that they that needs
+   * to be rendered in. For mobile platform this is default to be null so that these modules will
+   * need to provide a default surface delegate. One example of such native module is LogBoxModule,
+   * which is rendered in mobile platform with LogBoxDialog, while in VR platform with custom layer
+   * provided by runtime.
+   */
+  public ReactInstanceManagerBuilder setSurfaceDelegateFactory(
+      @Nullable final SurfaceDelegateFactory surfaceDelegateFactory) {
+    mSurfaceDelegateFactory = surfaceDelegateFactory;
+    return this;
+  }
+
   /**
    * Sets the initial lifecycle state of the host. For example, if the host is already resumed at
    * creation time, we wouldn't expect an onResume call until we get an onPause call.
@@ -283,6 +323,10 @@ public class ReactInstanceManagerBuilder {
         mJSMainModulePath,
         mPackages,
         mUseDeveloperSupport,
+        mDevSupportManagerFactory == null
+            ? new DefaultDevSupportManagerFactory()
+            : mDevSupportManagerFactory,
+        mRequireActivity,
         mBridgeIdleDebugListener,
         Assertions.assertNotNull(mInitialLifecycleState, "Initial lifecycle state was not set"),
         mUIImplementationProvider,
@@ -294,7 +338,8 @@ public class ReactInstanceManagerBuilder {
         mMinTimeLeftInFrameForNonBatchedOperationMs,
         mJSIModulesPackage,
         mCustomPackagerCommandHandlers,
-        mTMMDelegateBuilder);
+        mTMMDelegateBuilder,
+        mSurfaceDelegateFactory);
   }
 
   private JavaScriptExecutorFactory getDefaultJSExecutorFactory(

package/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java

@@ -15,6 +15,9 @@ import com.facebook.react.bridge.JavaScriptExecutorFactory;
 import com.facebook.react.bridge.ReactMarker;
 import com.facebook.react.bridge.ReactMarkerConstants;
 import com.facebook.react.common.LifecycleState;
+import com.facebook.react.common.SurfaceDelegate;
+import com.facebook.react.common.SurfaceDelegateFactory;
+import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.RedBoxHandler;
 import com.facebook.react.uimanager.UIImplementationProvider;
 import java.util.List;
@@ -68,6 +71,9 @@ public abstract class ReactNativeHost {
             .setApplication(mApplication)
             .setJSMainModulePath(getJSMainModuleName())
             .setUseDeveloperSupport(getUseDeveloperSupport())
+            .setDevSupportManagerFactory(getDevSupportManagerFactory())
+            .setRequireActivity(getShouldRequireActivity())
+            .setSurfaceDelegateFactory(getSurfaceDelegateFactory())
             .setRedBoxHandler(getRedBoxHandler())
             .setJavaScriptExecutorFactory(getJavaScriptExecutorFactory())
             .setUIImplementationProvider(getUIImplementationProvider())
@@ -124,6 +130,26 @@ public abstract class ReactNativeHost {
     return null;
   }
 
+  /** Returns whether or not to treat it as normal if Activity is null. */
+  public boolean getShouldRequireActivity() {
+    return true;
+  }
+
+  /**
+   * Return the {@link SurfaceDelegateFactory} used by NativeModules to get access to a {@link
+   * SurfaceDelegate} to interact with a surface. By default in the mobile platform the {@link
+   * SurfaceDelegate} it returns is null, and the NativeModule needs to implement its own {@link
+   * SurfaceDelegate} to decide how it would interact with its own container surface.
+   */
+  public SurfaceDelegateFactory getSurfaceDelegateFactory() {
+    return new SurfaceDelegateFactory() {
+      @Override
+      public @Nullable SurfaceDelegate createSurfaceDelegate(String moduleName) {
+        return null;
+      }
+    };
+  }
+
   /**
    * Returns the name of the main module. Determines the URL used to fetch the JS bundle from Metro.
    * It is only used when dev support is enabled. This is the first file to be executed once the
@@ -154,6 +180,11 @@ public abstract class ReactNativeHost {
   /** Returns whether dev mode should be enabled. This enables e.g. the dev menu. */
   public abstract boolean getUseDeveloperSupport();
 
+  /** Get the {@link DevSupportManagerFactory}. Override this to use a custom dev support manager */
+  protected @Nullable DevSupportManagerFactory getDevSupportManagerFactory() {
+    return null;
+  }
+
   /**
    * Returns a list of {@link ReactPackage} used by the app. You'll most likely want to return at
    * least the {@code MainReactPackage}. If your app uses additional views or modules besides the

package/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java

@@ -16,8 +16,10 @@ import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.Point;
 import android.graphics.Rect;
+import android.os.Build;
 import android.os.Bundle;
 import android.util.AttributeSet;
+import android.view.DisplayCutout;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.Surface;
@@ -647,6 +649,11 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     mJSTouchDispatcher = new JSTouchDispatcher(this);
   }
 
+  @VisibleForTesting
+  /* package */ void simulateCheckForKeyboardForTesting() {
+    getCustomGlobalLayoutListener().checkForKeyboardEvents();
+  }
+
   private CustomGlobalLayoutListener getCustomGlobalLayoutListener() {
     if (mCustomGlobalLayoutListener == null) {
       mCustomGlobalLayoutListener = new CustomGlobalLayoutListener();
@@ -766,8 +773,17 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
     private void checkForKeyboardEvents() {
       getRootView().getWindowVisibleDisplayFrame(mVisibleViewArea);
+      int notchHeight = 0;
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+        DisplayCutout displayCutout = getRootView().getRootWindowInsets().getDisplayCutout();
+        if (displayCutout != null) {
+          notchHeight = displayCutout.getSafeInsetTop();
+        }
+      }
       final int heightDiff =
-          DisplayMetricsHolder.getWindowDisplayMetrics().heightPixels - mVisibleViewArea.bottom;
+          DisplayMetricsHolder.getWindowDisplayMetrics().heightPixels
+              - mVisibleViewArea.bottom
+              + notchHeight;
 
       boolean isKeyboardShowingOrKeyboardHeightChanged =
           mKeyboardHeight != heightDiff && heightDiff > mMinKeyboardHeightDetected;

package/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.java

@@ -111,6 +111,8 @@ public interface CatalystInstance
 
   RuntimeExecutor getRuntimeExecutor();
 
+  RuntimeScheduler getRuntimeScheduler();
+
   void addJSIModules(List<JSIModuleSpec> jsiModules);
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstanceImpl.java

@@ -108,7 +108,8 @@ public class CatalystInstanceImpl implements CatalystInstance {
   // C++ parts
   private final HybridData mHybridData;
 
-  private static native HybridData initHybrid();
+  private static native HybridData initHybrid(
+      boolean enableRuntimeScheduler, boolean enableRuntimeSchedulerInTurboModule);
 
   public native CallInvokerHolderImpl getJSCallInvokerHolder();
 
@@ -123,7 +124,15 @@ public class CatalystInstanceImpl implements CatalystInstance {
     FLog.d(ReactConstants.TAG, "Initializing React Xplat Bridge.");
     Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "createCatalystInstanceImpl");
 
-    mHybridData = initHybrid();
+    if (ReactFeatureFlags.enableRuntimeSchedulerInTurboModule
+        && !ReactFeatureFlags.enableRuntimeScheduler) {
+      Assertions.assertUnreachable();
+    }
+
+    mHybridData =
+        initHybrid(
+            ReactFeatureFlags.enableRuntimeScheduler,
+            ReactFeatureFlags.enableRuntimeSchedulerInTurboModule);
 
     mReactQueueConfiguration =
         ReactQueueConfigurationImpl.create(
@@ -558,6 +567,8 @@ public class CatalystInstanceImpl implements CatalystInstance {
 
   public native RuntimeExecutor getRuntimeExecutor();
 
+  public native RuntimeScheduler getRuntimeScheduler();
+
   @Override
   public void addJSIModules(List<JSIModuleSpec> jsiModules) {
     mJSIModuleRegistry.registerModules(jsiModules);

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactContext.java

@@ -91,6 +91,7 @@ public class ReactContext extends ContextWrapper {
 
   /** Initialize message queue threads using a ReactQueueConfiguration. */
   public synchronized void initializeMessageQueueThreads(ReactQueueConfiguration queueConfig) {
+    FLog.w(TAG, "initializeMessageQueueThreads() is called.");
     if (mUiMessageQueueThread != null
         || mNativeModulesMessageQueueThread != null
         || mJSMessageQueueThread != null) {

package/ReactAndroid/src/main/java/com/facebook/react/bridge/ReactCxxErrorHandler.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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.bridge;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.proguard.annotations.DoNotStrip;
+import java.lang.reflect.Method;
+
+@DoNotStrip
+public class ReactCxxErrorHandler {
+
+  private static Method mHandleErrorFunc;
+  private static Object mObject;
+
+  @DoNotStrip
+  public static void setHandleErrorFunc(Object object, Method handleErrorFunc) {
+    mObject = object;
+    mHandleErrorFunc = handleErrorFunc;
+  }
+
+  @DoNotStrip
+  // For use from within the C++ JReactCxxErrorHandler
+  private static void handleError(final String message) {
+    if (mHandleErrorFunc != null) {
+      try {
+        Object[] parameters = new Object[1];
+        parameters[0] = new Exception(message);
+        mHandleErrorFunc.invoke(mObject, parameters);
+      } catch (Exception e) {
+        FLog.e("ReactCxxErrorHandler", "Failed to invole error hanlder function", e);
+      }
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/RuntimeScheduler.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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.bridge;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/** A Java holder for a C++ RuntimeScheduler. */
+public class RuntimeScheduler {
+
+  @DoNotStrip private HybridData mHybridData;
+
+  public RuntimeScheduler(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/common/BUCK

@@ -1,4 +1,4 @@
-load("//tools/build_defs/oss:rn_defs.bzl", "react_native_dep", "rn_android_build_config", "rn_android_library")
+load("//tools/build_defs/oss:rn_defs.bzl", "HERMES_BYTECODE_VERSION", "react_native_dep", "rn_android_build_config", "rn_android_library")
 
 SUB_PROJECTS = [
     "network/**/*",
@@ -41,7 +41,7 @@ rn_android_build_config(
     package = "com.facebook.react",
     values = [
         "boolean IS_INTERNAL_BUILD = true",
-        "int HERMES_BYTECODE_VERSION = 0",
+        "int HERMES_BYTECODE_VERSION = {}".format(HERMES_BYTECODE_VERSION),
     ],
     visibility = [
         "PUBLIC",

package/ReactAndroid/src/main/java/com/facebook/react/common/SurfaceDelegate.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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.common;
+
+/**
+ * Interface for handling a surface in React Native. In mobile platform a surface can be any
+ * container that holds some {@link View}. For example, a Dialog can be a surface to wrap content
+ * view object as needed. In VR platform, a surface is provided by Shell panel app sdk, which
+ * requires custom logic to show/hide. NativeModules requires a surface will delegate interactions
+ * with the surface to a SurfaceDelegate.
+ */
+public interface SurfaceDelegate {
+  /**
+   * Create the React content view that uses the appKey as the React application name
+   *
+   * @param appKey
+   */
+  void createContentView(String appKey);
+
+  /**
+   * Check if the content view is created and ready to be shown
+   *
+   * @return true if the content view is ready to be shown
+   */
+  boolean isContentViewReady();
+
+  /** Destroy the React content view to avoid memory leak */
+  void destroyContentView();
+
+  /** Show the surface containing the React content view */
+  void show();
+
+  /** Hide the surface containing the React content view */
+  void hide();
+}