Add single host inspector state assertion over CDP

Summary:
Introduces a new `InspectorSystemState` class and `ReactNativeApplication.systemStateChanged` CDP event, used to assert whether more than one React Native Host has been registered for the current app lifetime.

This will be used to disable the Performance and Network features in React Native DevTools when the debugger backend is in this currently unsupported state. We intend to implement host lifecycle correctness across all features soon.

Changelog: [Internal]

Differential Revision: D86201689

Author: huntie

packages/react-native/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -10,6 +10,7 @@
 
 #ifdef REACT_NATIVE_DEBUGGER_ENABLED
 #include "InspectorFlags.h"
+#include "InspectorSystemState.h"
 #include "NetworkIOAgent.h"
 #include "SessionState.h"
 #include "TracingAgent.h"
@@ -216,6 +217,9 @@ class HostAgent::Impl final {
           cdp::jsonNotification(
               "ReactNativeApplication.metadataUpdated",
               createHostMetadataPayload(hostMetadata_)));
+      if (!InspectorSystemState::getInstance().isSingleHost()) {
+        emitSystemStateChanged(false);
+      }
 
       auto stashedTraceRecording =
           targetController_.getDelegate()
@@ -374,6 +378,17 @@ class HostAgent::Impl final {
     tracingAgent_.emitExternalTraceRecording(std::move(traceRecording));
   }
 
+  void emitSystemStateChanged(bool isSingleHost) {
+    frontendChannel_(
+        cdp::jsonNotification(
+            "ReactNativeApplication.systemStateChanged",
+            folly::dynamic::object("isSingleHost", isSingleHost)));
+
+    if (!isSingleHost) {
+      frontendChannel_(cdp::jsonNotification("Network.disable"));
+    }
+  }
+
  private:
   enum class FuseboxClientType { Unknown, Fusebox, NonFusebox };
 
@@ -480,6 +495,7 @@ class HostAgent::Impl final {
   }
   void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) {
   }
+  void emitSystemStateChanged(bool isSingleHost) {}
 };
 
 #endif // REACT_NATIVE_DEBUGGER_ENABLED
@@ -519,6 +535,10 @@ void HostAgent::emitExternalTraceRecording(
   impl_->emitExternalTraceRecording(std::move(traceRecording));
 }
 
+void HostAgent::emitSystemStateChanged(bool isSingleHost) const {
+  impl_->emitSystemStateChanged(isSingleHost);
+}
+
 #pragma mark - Tracing
 
 HostTracingAgent::HostTracingAgent(tracing::TraceRecordingState& state)

packages/react-native/ReactCommon/jsinspector-modern/HostAgent.h

@@ -79,6 +79,12 @@ class HostAgent final {
    */
   void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) const;
 
+  /**
+   * Emits a system state changed event when the number of ReactHost instances
+   * changes.
+   */
+  void emitSystemStateChanged(bool isSingleHost) const;
+
  private:
   // We use the private implementation idiom to ensure this class has the same
   // layout regardless of whether REACT_NATIVE_DEBUGGER_ENABLED is defined. The

packages/react-native/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -115,6 +115,10 @@ class HostTargetSession {
     hostAgent_.emitExternalTraceRecording(std::move(traceRecording));
   }
 
+  void emitSystemStateChanged(bool isSingleHost) const {
+    hostAgent_.emitSystemStateChanged(isSingleHost);
+  }
+
  private:
   // Owned by this instance, but shared (weakly) with the frontend channel
   std::shared_ptr<RAIIRemoteConnection> remote_;
@@ -402,4 +406,10 @@ void HostTarget::emitTraceRecordingForFirstFuseboxClient(
   });
 }
 
+void HostTarget::emitSystemStateChanged(bool isSingleHost) const {
+  sessions_.forEach([isSingleHost](HostTargetSession& session) {
+    session.emitSystemStateChanged(isSingleHost);
+  });
+}
+
 } // namespace facebook::react::jsinspector_modern

packages/react-native/ReactCommon/jsinspector-modern/HostTarget.h

@@ -320,6 +320,11 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
    */
   void emitTraceRecordingForFirstFuseboxClient(tracing::TraceRecordingState traceRecording) const;
 
+  /**
+   * Emits a system state changed event to all active sessions.
+   */
+  void emitSystemStateChanged(bool isSingleHost) const;
+
  private:
   /**
    * Constructs a new HostTarget.

packages/react-native/ReactCommon/jsinspector-modern/InspectorSystemState.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "InspectorSystemState.h"
+
+#include <mutex>
+
+namespace facebook::react::jsinspector_modern {
+
+InspectorSystemState& InspectorSystemState::getInstance() {
+  static InspectorSystemState instance;
+  return instance;
+}
+
+void InspectorSystemState::incrementHostCount() {
+  int previousCount = hostCount_.fetch_add(1);
+  if (previousCount == 1) {
+    std::lock_guard<std::mutex> lock(callbackMutex_);
+    if (stateChangeCallback_) {
+      stateChangeCallback_(false);
+    }
+  }
+}
+
+bool InspectorSystemState::isSingleHost() const {
+  return hostCount_.load() <= 1;
+}
+
+void InspectorSystemState::setStateChangeCallback(
+    std::function<void(bool)> callback) {
+  std::lock_guard<std::mutex> lock(callbackMutex_);
+  stateChangeCallback_ = std::move(callback);
+}
+
+} // namespace facebook::react::jsinspector_modern

packages/react-native/ReactCommon/jsinspector-modern/InspectorSystemState.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <mutex>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * A singleton class that tracks system-wide state for the inspector
+ * (Meyers singleton pattern).
+ *
+ * TODO(huntie): Clean up this class and all calls once we implement host
+ * lifecycle correctness for Performance and Network.
+ */
+class InspectorSystemState {
+ public:
+  static InspectorSystemState &getInstance();
+
+  /**
+   * Increment the total count of React Hosts that have been registered during
+   * the app lifetime.
+   */
+  void incrementHostCount();
+
+  /**
+   * Check if the app has only registered a single host.
+   */
+  bool isSingleHost() const;
+
+  /**
+   * Set the callback to be invoked when the system state changes.
+   */
+  void setStateChangeCallback(std::function<void(bool)> callback);
+
+ private:
+  InspectorSystemState() = default;
+  InspectorSystemState(const InspectorSystemState &) = delete;
+  InspectorSystemState &operator=(const InspectorSystemState &) = delete;
+  ~InspectorSystemState() = default;
+
+  std::atomic<int> hostCount_{0};
+  std::mutex callbackMutex_;
+  std::function<void(bool)> stateChangeCallback_;
+};
+
+} // namespace facebook::react::jsinspector_modern

packages/react-native/ReactCxxPlatform/react/devsupport/inspector/Inspector.cpp

@@ -9,6 +9,7 @@
 #include "InspectorPackagerConnectionDelegate.h"
 
 #include <glog/logging.h>
+#include <jsinspector-modern/InspectorSystemState.h>
 #include <utility>
 
 namespace facebook::react {
@@ -194,6 +195,14 @@ void Inspector::ensureHostTarget(
         return nullptr;
       },
       capabilities);
+
+  jsinspector_modern::InspectorSystemState::getInstance()
+      .setStateChangeCallback(
+          [weakTarget = std::weak_ptr(target_)](bool isSingleHost) {
+            if (auto strongTarget = weakTarget.lock()) {
+              strongTarget->emitSystemStateChanged(isSingleHost);
+            }
+          });
 }
 
 void Inspector::invokeElsePost(

packages/react-native/ReactCxxPlatform/react/runtime/ReactHost.cpp

@@ -13,6 +13,7 @@
 #include <glog/logging.h>
 #include <jserrorhandler/JsErrorHandler.h>
 #include <jsinspector-modern/InspectorFlags.h>
+#include <jsinspector-modern/InspectorSystemState.h>
 #include <react/coremodules/AppStateModule.h>
 #include <react/coremodules/DeviceInfoModule.h>
 #include <react/coremodules/PlatformConstantsModule.h>
@@ -114,6 +115,7 @@ ReactHost::ReactHost(
            .has_value()) {
     throw std::runtime_error("No WebSocketClientFactory provided");
   }
+  jsinspector_modern::InspectorSystemState::getInstance().incrementHostCount();
   createReactInstance();
 }