Add RedBoxSurfaceDelegate to DevSupportManagerBase to abstract surface logic to show RedBox

Summary:
This diff adds `RedBoxSurfaceDelegate` to replace existing logic in `DevSupportManagerBase` to abstract how we show/hide the RedBox surface. The delegate will wrap a RedBoxDialog instance, which is used to show/hide the dialog for default behavior (when there is no surface delegate for redbox got provided).

I also updated the interface for delegate to accomodate new use cases:
- Add `isShowing` for the `SurfaceDelegate`
- Add a list of getters for `DevSupportManager` for data access in the delegate
- (Update 2/7) Separate Dialog from `RedBoxDialog`, and re-named it to `RedBoxContentView`. This is to make it clear that the delegate is responsible to provide actual surface implementation (Dialog). The content view is meant to be shared.

Changelog:
[Android][Internal]

Reviewed By: javache

Differential Revision: D33987835

fbshipit-source-id: 57c20648e7f2ec8238963feca27ccd5518e7931d

Author: ryancat

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

@@ -37,4 +37,7 @@ public interface SurfaceDelegate {
 
   /** Hide the surface containing the React content view */
   void hide();
+
+  /** Check if the surface is currently showing */
+  boolean isShowing();
 }

ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManagerBase.java

@@ -97,7 +97,7 @@ public interface CallbackWithBundleLoader {
   private final DefaultNativeModuleCallExceptionHandler mDefaultNativeModuleCallExceptionHandler;
   private final DevLoadingViewController mDevLoadingViewController;
 
-  private @Nullable RedBoxDialog mRedBoxDialog;
+  private @Nullable SurfaceDelegate mRedBoxSurfaceDelegate;
   private @Nullable AlertDialog mDevOptionsDialog;
   private @Nullable DebugOverlayController mDebugOverlayController;
   private boolean mDevLoadingViewVisible = false;
@@ -273,7 +273,8 @@ public void registerErrorCustomizer(ErrorCustomizer errorCustomizer) {
     mErrorCustomizers.add(errorCustomizer);
   }
 
-  private Pair<String, StackFrame[]> processErrorCustomizers(Pair<String, StackFrame[]> errorInfo) {
+  @Override
+  public Pair<String, StackFrame[]> processErrorCustomizers(Pair<String, StackFrame[]> errorInfo) {
     if (mErrorCustomizers == null) {
       return errorInfo;
     } else {
@@ -297,33 +298,25 @@ public void run() {
             // Since we only show the first JS error in a succession of JS errors, make sure we only
             // update the error message for that error message. This assumes that updateJSError
             // belongs to the most recent showNewJSError
-            if (mRedBoxDialog == null
-                || !mRedBoxDialog.isShowing()
-                || errorCookie != mLastErrorCookie) {
+            if (!mRedBoxSurfaceDelegate.isShowing() || errorCookie != mLastErrorCookie) {
               return;
             }
-            StackFrame[] stack = StackTraceHelper.convertJsStackTrace(details);
-            Pair<String, StackFrame[]> errorInfo =
-                processErrorCustomizers(Pair.create(message, stack));
-            mRedBoxDialog.setExceptionDetails(errorInfo.first, errorInfo.second);
-            updateLastErrorInfo(message, stack, errorCookie, ErrorType.JS);
-            // JS errors are reported here after source mapping.
-            if (mRedBoxHandler != null) {
-              mRedBoxHandler.handleRedbox(message, stack, ErrorType.JS);
-              mRedBoxDialog.resetReporting();
-            }
-            mRedBoxDialog.show();
+
+            // The RedBox surface delegate will always show the latest error
+            updateLastErrorInfo(
+                message, StackTraceHelper.convertJsStackTrace(details), errorCookie, ErrorType.JS);
+            mRedBoxSurfaceDelegate.show();
           }
         });
   }
 
   @Override
   public void hideRedboxDialog() {
-    // dismiss redbox if exists
-    if (mRedBoxDialog != null) {
-      mRedBoxDialog.dismiss();
-      mRedBoxDialog = null;
+    if (mRedBoxSurfaceDelegate == null) {
+      return;
     }
+
+    mRedBoxSurfaceDelegate.hide();
   }
 
   public @Nullable View createRootView(String appKey) {
@@ -350,41 +343,27 @@ private void showNewError(
         new Runnable() {
           @Override
           public void run() {
-            Activity context = mReactInstanceDevHelper.getCurrentActivity();
-            if (context != null && !context.isFinishing() && currentActivity != context) {
-              currentActivity = context;
-              // Create a new RedBox when currentActivity get updated
-              mRedBoxDialog =
-                  new RedBoxDialog(currentActivity, DevSupportManagerBase.this, mRedBoxHandler);
-            }
-            if (currentActivity == null || currentActivity.isFinishing()) {
-              FLog.e(
-                  ReactConstants.TAG,
-                  "Unable to launch redbox because react activity "
-                      + "is not available, here is the error that redbox would've displayed: "
-                      + message);
-              return;
-            }
-            if (mRedBoxDialog == null) {
-              mRedBoxDialog =
-                  new RedBoxDialog(currentActivity, DevSupportManagerBase.this, mRedBoxHandler);
+            if (mRedBoxSurfaceDelegate == null) {
+              @Nullable SurfaceDelegate redBoxSurfaceDelegate = createSurfaceDelegate("RedBox");
+              if (redBoxSurfaceDelegate != null) {
+                mRedBoxSurfaceDelegate = redBoxSurfaceDelegate;
+              } else {
+                mRedBoxSurfaceDelegate =
+                    new RedBoxDialogSurfaceDelegate(DevSupportManagerBase.this);
+              }
+
+              mRedBoxSurfaceDelegate.createContentView("RedBox");
             }
-            if (mRedBoxDialog.isShowing()) {
+
+            if (mRedBoxSurfaceDelegate.isShowing()) {
               // Sometimes errors cause multiple errors to be thrown in JS in quick succession. Only
               // show the first and most actionable one.
               return;
             }
-            Pair<String, StackFrame[]> errorInfo =
-                processErrorCustomizers(Pair.create(message, stack));
-            mRedBoxDialog.setExceptionDetails(errorInfo.first, errorInfo.second);
+
+            // The RedBox surface delegate will always show the latest error
             updateLastErrorInfo(message, stack, errorCookie, errorType);
-            // Only report native errors here. JS errors are reported
-            // inside {@link #updateJSError} after source mapping.
-            if (mRedBoxHandler != null && errorType == ErrorType.NATIVE) {
-              mRedBoxHandler.handleRedbox(message, stack, ErrorType.NATIVE);
-            }
-            mRedBoxDialog.resetReporting();
-            mRedBoxDialog.show();
+            mRedBoxSurfaceDelegate.show();
           }
         });
   }
@@ -623,6 +602,11 @@ public DevInternalSettings getDevSettings() {
     return mDevSettings;
   }
 
+  @Override
+  public RedBoxHandler getRedBoxHandler() {
+    return mRedBoxHandler;
+  }
+
   @Override
   public void onNewReactContextCreated(ReactContext reactContext) {
     resetCurrentContext(reactContext);
@@ -888,6 +872,11 @@ public void run() {
     return mLastErrorStack;
   }
 
+  @Override
+  public int getLastErrorCookie() {
+    return mLastErrorCookie;
+  }
+
   @Override
   public @Nullable ErrorType getLastErrorType() {
     return mLastErrorType;

ReactAndroid/src/main/java/com/facebook/react/devsupport/DisabledDevSupportManager.java

@@ -8,6 +8,7 @@
 package com.facebook.react.devsupport;
 
 import android.app.Activity;
+import android.util.Pair;
 import android.view.View;
 import androidx.annotation.Nullable;
 import com.facebook.react.bridge.DefaultNativeModuleCallExceptionHandler;
@@ -21,6 +22,7 @@
 import com.facebook.react.devsupport.interfaces.ErrorCustomizer;
 import com.facebook.react.devsupport.interfaces.ErrorType;
 import com.facebook.react.devsupport.interfaces.PackagerStatusCallback;
+import com.facebook.react.devsupport.interfaces.RedBoxHandler;
 import com.facebook.react.devsupport.interfaces.StackFrame;
 import com.facebook.react.modules.debug.interfaces.DeveloperSettings;
 import java.io.File;
@@ -94,6 +96,11 @@ public DeveloperSettings getDevSettings() {
     return null;
   }
 
+  @Override
+  public RedBoxHandler getRedBoxHandler() {
+    return null;
+  }
+
   @Override
   public void onNewReactContextCreated(ReactContext reactContext) {}
 
@@ -166,9 +173,19 @@ public void isPackagerRunning(final PackagerStatusCallback callback) {
     return null;
   }
 
+  @Override
+  public int getLastErrorCookie() {
+    return 0;
+  }
+
   @Override
   public void registerErrorCustomizer(ErrorCustomizer errorCustomizer) {}
 
+  @Override
+  public Pair<String, StackFrame[]> processErrorCustomizers(Pair<String, StackFrame[]> errorInfo) {
+    return errorInfo;
+  }
+
   @Override
   public void setPackagerLocationCustomizer(
       DevSupportManager.PackagerLocationCustomizer packagerLocationCustomizer) {}

ReactAndroid/src/main/java/com/facebook/react/devsupport/DoubleTapReloadRecognizer.java

@@ -14,7 +14,7 @@
 
 /**
  * A class allows recognizing double key tap of "R", used to reload JS in {@link
- * AbstractReactActivity}, {@link RedBoxDialog} and {@link ReactActivity}.
+ * AbstractReactActivity}, {@link RedBoxDialogSurfaceDelegate} and {@link ReactActivity}.
  */
 public class DoubleTapReloadRecognizer {
   private boolean mDoRefresh = false;

ReactAndroid/src/main/java/com/facebook/react/devsupport/LogBoxDialogSurfaceDelegate.java

@@ -55,7 +55,7 @@ public void destroyContentView() {
 
   @Override
   public void show() {
-    if (isSurfaceVisible() || !isContentViewReady()) {
+    if (isShowing() || !isContentViewReady()) {
       return;
     }
 
@@ -74,7 +74,7 @@ public void show() {
 
   @Override
   public void hide() {
-    if (!isSurfaceVisible()) {
+    if (!isShowing()) {
       return;
     }
 
@@ -86,7 +86,8 @@ public void hide() {
     mDialog = null;
   }
 
-  private boolean isSurfaceVisible() {
-    return mDialog != null;
+  @Override
+  public boolean isShowing() {
+    return mDialog != null && mDialog.isShowing();
   }
 }