react-native 0.0.0-17be3a003 → 0.0.0-18697adec

package/ReactAndroid/src/main/java/com/facebook/react/config/ReactFeatureFlags.java

@@ -7,6 +7,8 @@
 
 package com.facebook.react.config;
 
+import com.facebook.proguard.annotations.DoNotStripAny;
+
 /**
  * Hi there, traveller! This configuration class is not meant to be used by end-users of RN. It
  * contains mainly flags for features that are either under active development and not ready for
@@ -14,8 +16,8 @@ package com.facebook.react.config;
  *
  * <p>These values are safe defaults and should not require manual changes.
  */
+@DoNotStripAny
 public class ReactFeatureFlags {
-
   /**
    * Should this application use TurboModules? If yes, then any module that inherits {@link
    * com.facebook.react.turbomodule.core.interfaces.TurboModule} will NOT be passed in to C++
@@ -24,39 +26,43 @@ public class ReactFeatureFlags {
   public static volatile boolean useTurboModules = false;
 
   /**
-   * Should application use the new TM callback manager in Cxx? This is assumed to be a sane
-   * default, but it's new. We will delete once (1) we know it's safe to ship and (2) we have
-   * quantified impact.
+   * Should this application use the new (Fabric) Renderer? If yes, all rendering in this app will
+   * use Fabric instead of the legacy renderer.
+   */
+  public static volatile boolean enableFabricRenderer = false;
+
+  /**
+   * After TurboModules and Fabric are enabled, we need to ensure that the legacy NativeModule isn't
+   * isn't used. So, turn this flag on to trigger warnings whenever the legacy NativeModule system
+   * is used.
    */
-  public static volatile boolean useTurboModulesRAIICallbackManager = false;
+  public static volatile boolean warnOnLegacyNativeModuleSystemUse = false;
 
   /** Should we dispatch TurboModule methods with promise returns to the NativeModules thread? */
   public static volatile boolean enableTurboModulePromiseAsyncDispatch = false;
 
-  /*
-   * This feature flag enables logs for Fabric
-   */
-  public static boolean enableFabricLogs = false;
-
   /**
-   * Should this application use a {@link com.facebook.react.uimanager.ViewManagerDelegate} (if
-   * provided) to update the view properties. If {@code false}, then the generated {@code
-   * ...$$PropsSetter} class will be used instead.
+   * Experiment:
+   *
+   * <p>Bridge and Bridgeless mode can run concurrently. This means that there can be two
+   * TurboModule systems alive at the same time.
+   *
+   * <p>The TurboModule system stores all JS callbacks in a global LongLivedObjectCollection. This
+   * collection is cleared when the JS VM is torn down. Implication: Tearing down the bridge JSVM
+   * invalidates the bridgeless JSVM's callbacks, and vice versa.
+   *
+   * <p>useGlobalCallbackCleanupScopeUsingRetainJSCallback => Use a retainJSCallbacks lambda to
+   * store jsi::Functions into the global LongLivedObjectCollection
+   *
+   * <p>useTurboModuleManagerCallbackCleanupScope => Use a retainJSCallbacks labmda to store
+   * jsi::Functions into a LongLivedObjectCollection owned by the TurboModuleManager
    */
-  public static boolean useViewManagerDelegates = false;
+  public static boolean useGlobalCallbackCleanupScopeUsingRetainJSCallback = false;
 
-  /**
-   * Should this application use a {@link com.facebook.react.uimanager.ViewManagerDelegate} (if
-   * provided) to execute the view commands. If {@code false}, then {@code receiveCommand} method
-   * inside view manager will be called instead.
-   */
-  public static boolean useViewManagerDelegatesForCommands = false;
+  public static boolean useTurboModuleManagerCallbackCleanupScope = false;
 
-  /**
-   * Temporary feature flat to control a fix in the transition to layoutOnlyViews TODO T61185028:
-   * remove this when bug is fixed
-   */
-  public static boolean enableTransitionLayoutOnlyViewCleanup = false;
+  /** This feature flag enables logs for Fabric */
+  public static boolean enableFabricLogs = false;
 
   /** Feature flag to configure eager initialization of Fabric */
   public static boolean eagerInitializeFabric = false;
@@ -64,12 +70,31 @@ public class ReactFeatureFlags {
   /** Enables Static ViewConfig in RN Android native code. */
   public static boolean enableExperimentalStaticViewConfigs = false;
 
+  public static boolean enableRuntimeScheduler = false;
+
   /** Enables a more aggressive cleanup during destruction of ReactContext */
   public static boolean enableReactContextCleanupFix = false;
 
-  /** Enables JS Responder in Fabric */
-  public static boolean enableJSResponder = false;
+  /** Feature flag to configure eager initialization of MapBuffer So file */
+  public static boolean enableEagerInitializeMapBufferSoFile = false;
+
+  private static boolean mapBufferSerializationEnabled = false;
+
+  /** Enables or disables MapBuffer Serialization */
+  public static void setMapBufferSerializationEnabled(boolean enabled) {
+    mapBufferSerializationEnabled = enabled;
+  }
+
+  public static boolean isMapBufferSerializationEnabled() {
+    return mapBufferSerializationEnabled;
+  }
+
+  /** Enables Fabric for LogBox */
+  public static boolean enableFabricInLogBox = false;
+
+  public static boolean enableLockFreeEventDispatcher = false;
+
+  public static boolean enableAggressiveEventEmitterCleanup = false;
 
-  /** Enables MapBuffer Serialization */
-  public static boolean mapBufferSerializationEnabled = false;
+  public static boolean insertZReorderBarriersOnViewGroupChildren = true;
 }

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

@@ -40,7 +40,7 @@ rn_android_library(
         react_native_target("res:devsupport"),
     ],
     exported_deps = [
-        react_native_root_target("Libraries:FBReactNativeSpec"),
+        react_native_root_target(":FBReactNativeSpec"),
     ],
 )
 

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/BridgeDevSupportManager.java

@@ -0,0 +1,275 @@
+/*
+ * 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.devsupport;
+
+import android.content.Context;
+import android.widget.Toast;
+import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
+import com.facebook.debug.holder.PrinterHolder;
+import com.facebook.debug.tags.ReactDebugOverlayTags;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.CatalystInstance;
+import com.facebook.react.bridge.JSBundleLoader;
+import com.facebook.react.bridge.JavaJSExecutor;
+import com.facebook.react.bridge.JavaScriptExecutorFactory;
+import com.facebook.react.bridge.ReactMarker;
+import com.facebook.react.bridge.ReactMarkerConstants;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.futures.SimpleSettableFuture;
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+import com.facebook.react.devsupport.interfaces.DevOptionHandler;
+import com.facebook.react.devsupport.interfaces.DevSplitBundleCallback;
+import com.facebook.react.packagerconnection.RequestHandler;
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Interface for accessing and interacting with development features. Following features
+ * are supported through this manager class:
+ * 1) Displaying JS errors (aka RedBox)
+ * 2) Displaying developers menu (Reload JS, Debug JS)
+ * 3) Communication with developer server in order to download updated JS bundle
+ * 4) Starting/stopping broadcast receiver for js reload signals
+ * 5) Starting/stopping motion sensor listener that recognize shake gestures which in turn may
+ *    trigger developers menu.
+ * 6) Launching developers settings view
+ *
+ * This class automatically monitors the state of registered views and activities to which they are
+ * bound to make sure that we don't display overlay or that we we don't listen for sensor events
+ * when app is backgrounded.
+ *
+ * {@link com.facebook.react.ReactInstanceManager} implementation is responsible for instantiating
+ * this class as well as for populating with a reference to {@link CatalystInstance} whenever
+ * instance manager recreates it (through {@link #onNewReactContextCreated). Also, instance manager
+ * is responsible for enabling/disabling dev support in case when app is backgrounded or when all
+ * the views has been detached from the instance (through {@link #setDevSupportEnabled} method).
+ *
+ * IMPORTANT: In order for developer support to work correctly it is required that the
+ * manifest of your application contain the following entries:
+ * {@code <activity android:name="com.facebook.react.devsupport.DevSettingsActivity"/>}
+ * {@code <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>}
+ */
+public final class BridgeDevSupportManager extends DevSupportManagerBase {
+  private boolean mIsSamplingProfilerEnabled = false;
+
+  public BridgeDevSupportManager(
+      Context applicationContext,
+      ReactInstanceDevHelper reactInstanceManagerHelper,
+      @Nullable String packagerPathForJSBundleName,
+      boolean enableOnCreate,
+      @Nullable RedBoxHandler redBoxHandler,
+      @Nullable DevBundleDownloadListener devBundleDownloadListener,
+      int minNumShakes,
+      @Nullable Map<String, RequestHandler> customPackagerCommandHandlers) {
+    super(
+        applicationContext,
+        reactInstanceManagerHelper,
+        packagerPathForJSBundleName,
+        enableOnCreate,
+        redBoxHandler,
+        devBundleDownloadListener,
+        minNumShakes,
+        customPackagerCommandHandlers);
+
+    if (getDevSettings().isStartSamplingProfilerOnInit()) {
+      // Only start the profiler. If its already running, there is an error
+      if (!mIsSamplingProfilerEnabled) {
+        toggleJSSamplingProfiler();
+      } else {
+        Toast.makeText(
+                applicationContext,
+                "JS Sampling Profiler was already running, so did not start the sampling profiler",
+                Toast.LENGTH_LONG)
+            .show();
+      }
+    }
+
+    addCustomDevOption(
+        mIsSamplingProfilerEnabled
+            ? applicationContext.getString(
+                com.facebook.react.R.string.catalyst_sample_profiler_disable)
+            : applicationContext.getString(
+                com.facebook.react.R.string.catalyst_sample_profiler_enable),
+        new DevOptionHandler() {
+          @Override
+          public void onOptionSelected() {
+            toggleJSSamplingProfiler();
+          }
+        });
+
+    if (!getDevSettings().isDeviceDebugEnabled()) {
+      // For remote debugging, we open up Chrome running the app in a web worker.
+      // Note that this requires async communication, which will not work for Turbo Modules.
+      addCustomDevOption(
+          getDevSettings().isRemoteJSDebugEnabled()
+              ? applicationContext.getString(com.facebook.react.R.string.catalyst_debug_stop)
+              : applicationContext.getString(com.facebook.react.R.string.catalyst_debug),
+          new DevOptionHandler() {
+            @Override
+            public void onOptionSelected() {
+              getDevSettings().setRemoteJSDebugEnabled(!getDevSettings().isRemoteJSDebugEnabled());
+              handleReloadJS();
+            }
+          });
+    }
+  }
+
+  @Override
+  protected String getUniqueTag() {
+    return "Bridge";
+  }
+
+  @Override
+  public void loadSplitBundleFromServer(
+      final String bundlePath, final DevSplitBundleCallback callback) {
+    fetchSplitBundleAndCreateBundleLoader(
+        bundlePath,
+        new CallbackWithBundleLoader() {
+          @Override
+          public void onSuccess(JSBundleLoader bundleLoader) {
+            bundleLoader.loadScript(getCurrentContext().getCatalystInstance());
+            getCurrentContext()
+                .getJSModule(HMRClient.class)
+                .registerBundle(getDevServerHelper().getDevServerSplitBundleURL(bundlePath));
+            callback.onSuccess();
+          }
+
+          @Override
+          public void onError(String url, Throwable cause) {
+            callback.onError(url, cause);
+          }
+        });
+  }
+
+  private WebsocketJavaScriptExecutor.JSExecutorConnectCallback getExecutorConnectCallback(
+      final SimpleSettableFuture<Boolean> future) {
+    return new WebsocketJavaScriptExecutor.JSExecutorConnectCallback() {
+      @Override
+      public void onSuccess() {
+        future.set(true);
+        hideDevLoadingView();
+      }
+
+      @Override
+      public void onFailure(final Throwable cause) {
+        hideDevLoadingView();
+        FLog.e(ReactConstants.TAG, "Failed to connect to debugger!", cause);
+        future.setException(
+            new IOException(
+                getApplicationContext().getString(com.facebook.react.R.string.catalyst_debug_error),
+                cause));
+      }
+    };
+  }
+
+  private void reloadJSInProxyMode() {
+    // When using js proxy, there is no need to fetch JS bundle as proxy executor will do that
+    // anyway
+    getDevServerHelper().launchJSDevtools();
+
+    JavaJSExecutor.Factory factory =
+        new JavaJSExecutor.Factory() {
+          @Override
+          public JavaJSExecutor create() throws Exception {
+            WebsocketJavaScriptExecutor executor = new WebsocketJavaScriptExecutor();
+            SimpleSettableFuture<Boolean> future = new SimpleSettableFuture<>();
+            executor.connect(
+                getDevServerHelper().getWebsocketProxyURL(), getExecutorConnectCallback(future));
+            // TODO(t9349129) Don't use timeout
+            try {
+              future.get(90, TimeUnit.SECONDS);
+              return executor;
+            } catch (ExecutionException e) {
+              throw (Exception) e.getCause();
+            } catch (InterruptedException | TimeoutException e) {
+              throw new RuntimeException(e);
+            }
+          }
+        };
+    getReactInstanceDevHelper().onReloadWithJSDebugger(factory);
+  }
+
+  @Override
+  public void handleReloadJS() {
+
+    UiThreadUtil.assertOnUiThread();
+
+    ReactMarker.logMarker(
+        ReactMarkerConstants.RELOAD,
+        getDevSettings().getPackagerConnectionSettings().getDebugServerHost());
+
+    // dismiss redbox if exists
+    hideRedboxDialog();
+
+    if (getDevSettings().isRemoteJSDebugEnabled()) {
+      PrinterHolder.getPrinter()
+          .logMessage(ReactDebugOverlayTags.RN_CORE, "RNCore: load from Proxy");
+      showDevLoadingViewForRemoteJSEnabled();
+      reloadJSInProxyMode();
+    } else {
+      PrinterHolder.getPrinter()
+          .logMessage(ReactDebugOverlayTags.RN_CORE, "RNCore: load from Server");
+      String bundleURL =
+          getDevServerHelper()
+              .getDevServerBundleURL(Assertions.assertNotNull(getJSAppBundleName()));
+      reloadJSFromServer(bundleURL);
+    }
+  }
+
+  /** Starts of stops the sampling profiler */
+  private void toggleJSSamplingProfiler() {
+    JavaScriptExecutorFactory javaScriptExecutorFactory =
+        getReactInstanceDevHelper().getJavaScriptExecutorFactory();
+    if (!mIsSamplingProfilerEnabled) {
+      try {
+        javaScriptExecutorFactory.startSamplingProfiler();
+        Toast.makeText(getApplicationContext(), "Starting Sampling Profiler", Toast.LENGTH_SHORT)
+            .show();
+      } catch (UnsupportedOperationException e) {
+        Toast.makeText(
+                getApplicationContext(),
+                javaScriptExecutorFactory.toString() + " does not support Sampling Profiler",
+                Toast.LENGTH_LONG)
+            .show();
+      } finally {
+        mIsSamplingProfilerEnabled = true;
+      }
+    } else {
+      try {
+        final String outputPath =
+            File.createTempFile(
+                    "sampling-profiler-trace", ".cpuprofile", getApplicationContext().getCacheDir())
+                .getPath();
+        javaScriptExecutorFactory.stopSamplingProfiler(outputPath);
+        Toast.makeText(
+                getApplicationContext(),
+                "Saved results from Profiler to " + outputPath,
+                Toast.LENGTH_LONG)
+            .show();
+      } catch (IOException e) {
+        FLog.e(
+            ReactConstants.TAG,
+            "Could not create temporary file for saving results from Sampling Profiler");
+      } catch (UnsupportedOperationException e) {
+        Toast.makeText(
+                getApplicationContext(),
+                javaScriptExecutorFactory.toString() + "does not support Sampling Profiler",
+                Toast.LENGTH_LONG)
+            .show();
+      } finally {
+        mIsSamplingProfilerEnabled = false;
+      }
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DefaultDevSupportManagerFactory.java

@@ -0,0 +1,97 @@
+/*
+ * 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.devsupport;
+
+import android.content.Context;
+import androidx.annotation.Nullable;
+import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.packagerconnection.RequestHandler;
+import java.lang.reflect.Constructor;
+import java.util.Map;
+
+/**
+ * A simple factory that creates instances of {@link DevSupportManager} implementations. Uses
+ * reflection to create BridgeDevSupportManager if it exists. This allows ProGuard to strip that
+ * class and its dependencies in release builds. If the class isn't found, {@link
+ * DisabledDevSupportManager} is returned instead.
+ */
+public class DefaultDevSupportManagerFactory implements DevSupportManagerFactory {
+
+  private static final String DEVSUPPORT_IMPL_PACKAGE = "com.facebook.react.devsupport";
+  private static final String DEVSUPPORT_IMPL_CLASS = "BridgeDevSupportManager";
+
+  public DevSupportManager create(
+      Context applicationContext,
+      ReactInstanceDevHelper reactInstanceDevHelper,
+      @Nullable String packagerPathForJSBundleName,
+      boolean enableOnCreate,
+      int minNumShakes) {
+
+    return create(
+        applicationContext,
+        reactInstanceDevHelper,
+        packagerPathForJSBundleName,
+        enableOnCreate,
+        null,
+        null,
+        minNumShakes,
+        null);
+  }
+
+  @Override
+  public DevSupportManager create(
+      Context applicationContext,
+      ReactInstanceDevHelper reactInstanceManagerHelper,
+      @Nullable String packagerPathForJSBundleName,
+      boolean enableOnCreate,
+      @Nullable RedBoxHandler redBoxHandler,
+      @Nullable DevBundleDownloadListener devBundleDownloadListener,
+      int minNumShakes,
+      @Nullable Map<String, RequestHandler> customPackagerCommandHandlers) {
+    if (!enableOnCreate) {
+      return new DisabledDevSupportManager();
+    }
+    try {
+      // ProGuard is surprisingly smart in this case and will keep a class if it detects a call to
+      // Class.forName() with a static string. So instead we generate a quasi-dynamic string to
+      // confuse it.
+      String className =
+          new StringBuilder(DEVSUPPORT_IMPL_PACKAGE)
+              .append(".")
+              .append(DEVSUPPORT_IMPL_CLASS)
+              .toString();
+      Class<?> devSupportManagerClass = Class.forName(className);
+      Constructor constructor =
+          devSupportManagerClass.getConstructor(
+              Context.class,
+              ReactInstanceDevHelper.class,
+              String.class,
+              boolean.class,
+              RedBoxHandler.class,
+              DevBundleDownloadListener.class,
+              int.class,
+              Map.class);
+      return (DevSupportManager)
+          constructor.newInstance(
+              applicationContext,
+              reactInstanceManagerHelper,
+              packagerPathForJSBundleName,
+              true,
+              redBoxHandler,
+              devBundleDownloadListener,
+              minNumShakes,
+              customPackagerCommandHandlers);
+    } catch (Exception e) {
+      throw new RuntimeException(
+          "Requested enabled DevSupportManager, but BridgeDevSupportManager class was not found"
+              + " or could not be created",
+          e);
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevServerHelper.java

@@ -41,7 +41,6 @@ import okhttp3.OkHttpClient;
 import okhttp3.Request;
 import okhttp3.RequestBody;
 import okhttp3.Response;
-import okhttp3.ResponseBody;
 import okio.Okio;
 import okio.Sink;
 import org.json.JSONArray;
@@ -63,8 +62,6 @@ import org.json.JSONObject;
 public class DevServerHelper {
   public static final String RELOAD_APP_EXTRA_JS_PROXY = "jsproxy";
 
-  private static final String PACKAGER_OK_STATUS = "packager-status:running";
-
   private static final int HTTP_CONNECT_TIMEOUT_MS = 5000;
 
   private static final String DEBUGGER_MSG_DISABLE = "{ \"id\":1,\"method\":\"Debugger.disable\" }";
@@ -113,6 +110,7 @@ public class DevServerHelper {
   private final DevInternalSettings mSettings;
   private final OkHttpClient mClient;
   private final BundleDownloader mBundleDownloader;
+  private final PackagerStatusCheck mPackagerStatusCheck;
   private final String mPackageName;
 
   private @Nullable JSPackagerClient mPackagerClient;
@@ -132,7 +130,7 @@ public class DevServerHelper {
             .writeTimeout(0, TimeUnit.MILLISECONDS)
             .build();
     mBundleDownloader = new BundleDownloader(mClient);
-
+    mPackagerStatusCheck = new PackagerStatusCheck(mClient);
     mPackageName = packageName;
   }
 
@@ -477,60 +475,13 @@ public class DevServerHelper {
   }
 
   public void isPackagerRunning(final PackagerStatusCallback callback) {
-    String statusURL =
-        createPackagerStatusURL(mSettings.getPackagerConnectionSettings().getDebugServerHost());
-    Request request = new Request.Builder().url(statusURL).build();
-
-    mClient
-        .newCall(request)
-        .enqueue(
-            new Callback() {
-              @Override
-              public void onFailure(Call call, IOException e) {
-                FLog.w(
-                    ReactConstants.TAG,
-                    "The packager does not seem to be running as we got an IOException requesting "
-                        + "its status: "
-                        + e.getMessage());
-                callback.onPackagerStatusFetched(false);
-              }
-
-              @Override
-              public void onResponse(Call call, Response response) throws IOException {
-                if (!response.isSuccessful()) {
-                  FLog.e(
-                      ReactConstants.TAG,
-                      "Got non-success http code from packager when requesting status: "
-                          + response.code());
-                  callback.onPackagerStatusFetched(false);
-                  return;
-                }
-                ResponseBody body = response.body();
-                if (body == null) {
-                  FLog.e(
-                      ReactConstants.TAG,
-                      "Got null body response from packager when requesting status");
-                  callback.onPackagerStatusFetched(false);
-                  return;
-                }
-                String bodyString =
-                    body.string(); // cannot call body.string() twice, stored it into variable.
-                // https://github.com/square/okhttp/issues/1240#issuecomment-68142603
-                if (!PACKAGER_OK_STATUS.equals(bodyString)) {
-                  FLog.e(
-                      ReactConstants.TAG,
-                      "Got unexpected response from packager when requesting status: "
-                          + bodyString);
-                  callback.onPackagerStatusFetched(false);
-                  return;
-                }
-                callback.onPackagerStatusFetched(true);
-              }
-            });
-  }
-
-  private static String createPackagerStatusURL(String host) {
-    return String.format(Locale.US, "http://%s/status", host);
+    String host = mSettings.getPackagerConnectionSettings().getDebugServerHost();
+    if (host == null) {
+      FLog.w(ReactConstants.TAG, "No packager host configured.");
+      callback.onPackagerStatusFetched(false);
+    } else {
+      mPackagerStatusCheck.run(host, callback);
+    }
   }
 
   private String createLaunchJSDevtoolsCommandUrl() {