Handle all incoming Inspector messages on main thread, downgrade some errors to logs

Summary:
Changelog: [Internal]

* Updates `InspectorPackagerConnection.java`, `DevServerHelper.java` and `DevSupportManagerBase.java` to perform all connection management and message dispatching for the inspector socket on the main thread. This is in support of a new CDP implementation in React Native that will strictly assume it's called on the main thread (thus avoiding the need for explicit locking in many places).
* Downgrades JSON parsing errors and duplicate connection errors from exceptions to logs, matching the [iOS implementation](https://github.com/facebook/react-native/blob/main/packages/react-native/React/Inspector/RCTInspectorPackagerConnection.m).

Reviewed By: javache

Differential Revision: D51346658

fbshipit-source-id: 3d0d5588a824c1b28da5499ef9d040998a941288

Author: motiz88

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevServerHelper.java

@@ -210,16 +210,10 @@ public void openInspectorConnection() {
       FLog.w(ReactConstants.TAG, "Inspector connection already open, nooping.");
       return;
     }
-    new AsyncTask<Void, Void, Void>() {
-      @Override
-      protected Void doInBackground(Void... params) {
-        mInspectorPackagerConnection =
-            new InspectorPackagerConnection(
-                getInspectorDeviceUrl(), mPackageName, mBundlerStatusProvider);
-        mInspectorPackagerConnection.connect();
-        return null;
-      }
-    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    mInspectorPackagerConnection =
+        new InspectorPackagerConnection(
+            getInspectorDeviceUrl(), mPackageName, mBundlerStatusProvider);
+    mInspectorPackagerConnection.connect();
   }
 
   public void disableDebugger() {
@@ -229,16 +223,10 @@ public void disableDebugger() {
   }
 
   public void closeInspectorConnection() {
-    new AsyncTask<Void, Void, Void>() {
-      @Override
-      protected Void doInBackground(Void... params) {
-        if (mInspectorPackagerConnection != null) {
-          mInspectorPackagerConnection.closeQuietly();
-          mInspectorPackagerConnection = null;
-        }
-        return null;
-      }
-    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    if (mInspectorPackagerConnection != null) {
+      mInspectorPackagerConnection.closeQuietly();
+      mInspectorPackagerConnection = null;
+    }
   }
 
   public String getWebsocketProxyURL() {

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/devsupport/DevSupportManagerBase.java

@@ -942,13 +942,15 @@ private void reportBundleLoadingFailure(final Exception cause) {
 
   @Override
   public void startInspector() {
+    UiThreadUtil.assertOnUiThread();
     if (mIsDevSupportEnabled) {
       mDevServerHelper.openInspectorConnection();
     }
   }
 
   @Override
   public void stopInspector() {
+    UiThreadUtil.assertOnUiThread();
     mDevServerHelper.closeInspectorConnection();
   }
 
@@ -1045,9 +1047,12 @@ public void onPackagerDisconnected() {
 
             @Override
             public void onPackagerReloadCommand() {
-              // Disable debugger to resume the JsVM & avoid thread locks while reloading
-              mDevServerHelper.disableDebugger();
-              UiThreadUtil.runOnUiThread(() -> handleReloadJS());
+              UiThreadUtil.runOnUiThread(
+                  () -> {
+                    // Disable debugger to resume the JsVM & avoid thread locks while reloading
+                    mDevServerHelper.disableDebugger();
+                    handleReloadJS();
+                  });
             }
 
             @Override

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/devsupport/InspectorPackagerConnection.java

@@ -8,12 +8,10 @@
 package com.facebook.react.devsupport;
 
 import android.os.AsyncTask;
-import android.os.Handler;
-import android.os.Looper;
 import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
 import com.facebook.react.bridge.Inspector;
-import java.io.IOException;
+import com.facebook.react.bridge.UiThreadUtil;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -37,17 +35,20 @@ public class InspectorPackagerConnection {
 
   public InspectorPackagerConnection(
       String url, String packageName, BundleStatusProvider bundleStatusProvider) {
+    UiThreadUtil.assertOnUiThread();
     mConnection = new Connection(url);
     mInspectorConnections = new HashMap<>();
     mPackageName = packageName;
     mBundleStatusProvider = bundleStatusProvider;
   }
 
   public void connect() {
+    UiThreadUtil.assertOnUiThread();
     mConnection.connect();
   }
 
   public void closeQuietly() {
+    UiThreadUtil.assertOnUiThread();
     mConnection.close();
   }
 
@@ -59,7 +60,7 @@ public void sendEventToAllConnections(String event) {
     }
   }
 
-  void handleProxyMessage(JSONObject message) throws JSONException, IOException {
+  void handleProxyMessage(JSONObject message) throws JSONException {
     String event = message.getString("event");
     switch (event) {
       case "getPages":
@@ -75,7 +76,8 @@ void handleProxyMessage(JSONObject message) throws JSONException, IOException {
         handleDisconnect(message.getJSONObject("payload"));
         break;
       default:
-        throw new IllegalArgumentException("Unknown event: " + event);
+        FLog.e(TAG, "Unknown event: " + event);
+        break;
     }
   }
 
@@ -90,7 +92,8 @@ private void handleConnect(JSONObject payload) throws JSONException {
     final String pageId = payload.getString("pageId");
     Inspector.LocalConnection inspectorConnection = mInspectorConnections.remove(pageId);
     if (inspectorConnection != null) {
-      throw new IllegalStateException("Already connected: " + pageId);
+      FLog.w(TAG, "Already connected: " + pageId);
+      return;
     }
 
     try {
@@ -191,49 +194,65 @@ private class Connection extends WebSocketListener {
 
     private OkHttpClient mHttpClient;
     private @Nullable WebSocket mWebSocket;
-    private final Handler mHandler;
     private boolean mClosed;
     private boolean mSuppressConnectionErrors;
 
     public Connection(String url) {
       mUrl = url;
-      mHandler = new Handler(Looper.getMainLooper());
     }
 
     @Override
     public void onOpen(WebSocket webSocket, Response response) {
-      mWebSocket = webSocket;
+      UiThreadUtil.runOnUiThread(
+          () -> {
+            mWebSocket = webSocket;
+          });
     }
 
     @Override
     public void onFailure(WebSocket webSocket, Throwable t, Response response) {
-      if (mWebSocket != null) {
-        abort("Websocket exception", t);
-      }
-      if (!mClosed) {
-        reconnect();
-      }
+      UiThreadUtil.runOnUiThread(
+          () -> {
+            if (mWebSocket != null) {
+              abort("Websocket exception", t);
+            }
+            if (!mClosed) {
+              reconnect();
+            }
+          });
     }
 
     @Override
     public void onMessage(WebSocket webSocket, String text) {
       try {
-        handleProxyMessage(new JSONObject(text));
-      } catch (Exception e) {
-        throw new RuntimeException(e);
+        JSONObject parsed = new JSONObject(text);
+        UiThreadUtil.runOnUiThread(
+            () -> {
+              try {
+                handleProxyMessage(parsed);
+              } catch (JSONException e) {
+                FLog.w(TAG, "Error handling inspector message", e);
+              }
+            });
+      } catch (JSONException e) {
+        FLog.w(TAG, "Unrecognized inspector message, string was not valid JSON: " + text, e);
       }
     }
 
     @Override
     public void onClosed(WebSocket webSocket, int code, String reason) {
-      mWebSocket = null;
-      closeAllConnections();
-      if (!mClosed) {
-        reconnect();
-      }
+      UiThreadUtil.runOnUiThread(
+          () -> {
+            mWebSocket = null;
+            closeAllConnections();
+            if (!mClosed) {
+              reconnect();
+            }
+          });
     }
 
     public void connect() {
+      UiThreadUtil.assertOnUiThread();
       if (mClosed) {
         throw new IllegalStateException("Can't connect closed client");
       }
@@ -258,20 +277,18 @@ private void reconnect() {
         FLog.w(TAG, "Couldn't connect to packager, will silently retry");
         mSuppressConnectionErrors = true;
       }
-      mHandler.postDelayed(
-          new Runnable() {
-            @Override
-            public void run() {
-              // check that we haven't been closed in the meantime
-              if (!mClosed) {
-                connect();
-              }
+      UiThreadUtil.runOnUiThread(
+          () -> {
+            // check that we haven't been closed in the meantime
+            if (!mClosed) {
+              connect();
             }
           },
           RECONNECT_DELAY_MS);
     }
 
     public void close() {
+      UiThreadUtil.assertOnUiThread();
       mClosed = true;
       if (mWebSocket != null) {
         try {