Define TracingDelegate for Android Host (#54628)

Summary:
Pull Request resolved: #54628

# Changelog: [Internal]

An implemementation of HostTargetTracingDelegate on the android side.

Notes:
- `getTracingState_next()` function will replace `getTracingState()` in the diff on top.
- `TracingStateListener `is temporarily added to `devsupport/interfaces`, will be moved to `devsupport/inspector` in one of the diffs on top.

Reviewed By: sbuggay

Differential Revision: D87123723

fbshipit-source-id: 02083e3a63a2effc0dbbc7284b61c41a4c63584a

Author: hoxyq

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/devsupport/interfaces/TracingStateListener.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.
+ */
+
+package com.facebook.react.devsupport.interfaces
+
+import com.facebook.proguard.annotations.DoNotStripAny
+
+@DoNotStripAny
+internal fun interface TracingStateListener {
+  public fun onStateChanged(state: TracingState, screenshotsEnabled: Boolean)
+}

packages/react-native/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostInspectorTarget.kt

@@ -13,6 +13,7 @@ import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.common.annotations.FrameworkAPI
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
 import com.facebook.react.devsupport.interfaces.TracingState
+import com.facebook.react.devsupport.interfaces.TracingStateListener
 import com.facebook.react.devsupport.perfmonitor.PerfMonitorInspectorTarget
 import com.facebook.react.devsupport.perfmonitor.PerfMonitorUpdateListener
 import com.facebook.soloader.SoLoader
@@ -43,6 +44,12 @@ internal class ReactHostInspectorTarget(reactHostImpl: ReactHostImpl) :
 
   external fun tracingStateAsInt(): Int
 
+  external fun getTracingState_next(): TracingState
+
+  external fun registerTracingStateListener(listener: TracingStateListener): Long
+
+  external fun unregisterTracingStateListener(subscriptionId: Long)
+
   override fun getTracingState(): TracingState {
     return TracingState.entries[tracingStateAsInt()]
   }

packages/react-native/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.cpp

@@ -16,6 +16,36 @@ using namespace facebook::jni;
 using namespace facebook::react::jsinspector_modern;
 
 namespace facebook::react {
+
+namespace {
+jni::local_ref<JTracingState::javaobject> convertCPPTracingStateToJava(
+    TracingState tracingState) {
+  auto tracingStateClass = jni::findClassLocal(
+      "com/facebook/react/devsupport/interfaces/TracingState");
+  auto valueOfMethod =
+      tracingStateClass->getStaticMethod<JTracingState(jstring)>("valueOf");
+
+  switch (tracingState) {
+    case TracingState::Disabled:
+      return valueOfMethod(
+          tracingStateClass, jni::make_jstring("DISABLED").get());
+
+    case TracingState::EnabledInBackgroundMode:
+      return valueOfMethod(
+          tracingStateClass,
+          jni::make_jstring("ENABLEDINBACKGROUNDMODE").get());
+
+    case TracingState::EnabledInCDPMode:
+      return valueOfMethod(
+          tracingStateClass, jni::make_jstring("ENABLEDINCDPMODE").get());
+
+    default:
+      jni::throwNewJavaException(
+          "java/lang/IllegalStateException", "Unexpected new TracingState.");
+  }
+}
+} // namespace
+
 JReactHostInspectorTarget::JReactHostInspectorTarget(
     alias_ref<JReactHostInspectorTarget::javaobject> jobj,
     alias_ref<JReactHostImpl> reactHostImpl,
@@ -29,7 +59,8 @@ JReactHostInspectorTarget::JReactHostInspectorTarget(
                              std::function<void()>&& callback) mutable {
         auto jrunnable = JNativeRunnable::newObjectCxxArgs(std::move(callback));
         javaExecutor->execute(jrunnable);
-      }) {
+      }),
+      tracingDelegate_(std::make_unique<TracingDelegate>()) {
   auto& inspectorFlags = InspectorFlags::getInstance();
   if (inspectorFlags.getFuseboxEnabled()) {
     inspectorTarget_ = HostTarget::create(*this, inspectorExecutor_);
@@ -216,6 +247,14 @@ void JReactHostInspectorTarget::registerNatives() {
           JReactHostInspectorTarget::stopAndDiscardBackgroundTrace),
       makeNativeMethod(
           "tracingStateAsInt", JReactHostInspectorTarget::tracingState),
+      makeNativeMethod(
+          "getTracingState_next", JReactHostInspectorTarget::getTracingState),
+      makeNativeMethod(
+          "registerTracingStateListener",
+          JReactHostInspectorTarget::registerTracingStateListener),
+      makeNativeMethod(
+          "unregisterTracingStateListener",
+          JReactHostInspectorTarget::unregisterTracingStateListener),
   });
 }
 
@@ -224,4 +263,117 @@ jint JReactHostInspectorTarget::tracingState() {
   return static_cast<jint>(state);
 }
 
+jni::local_ref<JTracingState::javaobject>
+JReactHostInspectorTarget::getTracingState() {
+  return convertCPPTracingStateToJava(tracingDelegate_->getTracingState());
+}
+
+jlong JReactHostInspectorTarget::registerTracingStateListener(
+    jni::alias_ref<JTracingStateListener::javaobject> listener) {
+  auto cppListener = [globalRef = make_global(listener)](
+                         TracingState state, bool screenshotsEnabled) {
+    static auto method =
+        globalRef->getClass()
+            ->getMethod<void(
+                jni::local_ref<JTracingState::javaobject>, jboolean)>(
+                "onStateChanged");
+
+    method(
+        globalRef,
+        convertCPPTracingStateToJava(state),
+        static_cast<jboolean>(screenshotsEnabled));
+  };
+
+  return static_cast<jlong>(
+      tracingDelegate_->registerTracingStateListener(std::move(cppListener)));
+}
+
+void JReactHostInspectorTarget::unregisterTracingStateListener(
+    jlong subscriptionId) {
+  tracingDelegate_->unregisterTracingStateListener(subscriptionId);
+}
+
+HostTargetTracingDelegate* JReactHostInspectorTarget::getTracingDelegate() {
+  return tracingDelegate_.get();
+}
+
+void TracingDelegate::onTracingStarted(
+    tracing::Mode tracingMode,
+    bool screenshotsCategoryEnabled) {
+  TracingState nextState = TracingState::Disabled;
+  switch (tracingMode) {
+    case tracing::Mode::CDP:
+      nextState = TracingState::EnabledInCDPMode;
+      break;
+    case tracing::Mode::Background:
+      nextState = TracingState::EnabledInBackgroundMode;
+      break;
+    default:
+      throw std::logic_error("Unexpected new Tracing Mode");
+  }
+
+  std::vector<TracingStateListener> listeners;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    tracingState_ = nextState;
+    listeners = copySubscribedListeners();
+  }
+
+  notifyListeners(listeners, nextState, screenshotsCategoryEnabled);
+}
+
+void TracingDelegate::onTracingStopped() {
+  std::vector<TracingStateListener> listeners;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    tracingState_ = TracingState::Disabled;
+    listeners = copySubscribedListeners();
+  }
+
+  notifyListeners(listeners, TracingState::Disabled, false);
+}
+
+TracingState TracingDelegate::getTracingState() {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  return tracingState_;
+}
+
+size_t TracingDelegate::registerTracingStateListener(
+    TracingStateListener listener) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  auto id = nextSubscriptionId_++;
+  subscriptions_[id] = std::move(listener);
+  return id;
+}
+
+void TracingDelegate::unregisterTracingStateListener(size_t subscriptionId) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  subscriptions_.erase(subscriptionId);
+}
+
+std::vector<TracingStateListener> TracingDelegate::copySubscribedListeners() {
+  std::vector<TracingStateListener> listeners;
+  listeners.reserve(subscriptions_.size());
+
+  for (auto& [_, listener] : subscriptions_) {
+    listeners.push_back(listener);
+  }
+
+  return listeners;
+}
+
+void TracingDelegate::notifyListeners(
+    const std::vector<TracingStateListener>& listeners,
+    TracingState state,
+    bool screenshotsCategoryEnabled) {
+  for (const auto& listener : listeners) {
+    listener(state, screenshotsCategoryEnabled);
+  }
+}
+
 } // namespace facebook::react

packages/react-native/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.h

@@ -8,10 +8,15 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
+
 #include <jsinspector-modern/HostTarget.h>
 #include <react/jni/InspectorNetworkRequestListener.h>
 #include <react/jni/JExecutor.h>
+
+#include <mutex>
+#include <optional>
 #include <string>
+#include <vector>
 
 namespace facebook::react {
 
@@ -20,7 +25,11 @@ struct JTaskInterface : public jni::JavaClass<JTaskInterface> {
 };
 
 struct JTracingState : public jni::JavaClass<JTracingState> {
-  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/TracingState;";
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/interfaces/TracingState;";
+};
+
+struct JTracingStateListener : public jni::JavaClass<JTracingStateListener> {
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/interfaces/TracingStateListener;";
 };
 
 struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {
@@ -55,6 +64,71 @@ struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {
   }
 };
 
+enum class TracingState {
+  Disabled,
+  EnabledInBackgroundMode,
+  EnabledInCDPMode,
+};
+
+/**
+ * A callback that will be invoked when tracing state has changed.
+ */
+using TracingStateListener = std::function<void(TracingState state, bool screenshotsCategoryEnabled)>;
+
+class TracingDelegate : public jsinspector_modern::HostTargetTracingDelegate {
+ public:
+  void onTracingStarted(jsinspector_modern::tracing::Mode tracingMode, bool screenshotsCategoryEnabled) override;
+  void onTracingStopped() override;
+
+  /**
+   * A synchronous way to get the current tracing state.
+   * Could be called from any thread.
+   */
+  TracingState getTracingState();
+  /**
+   * Register a listener that will be notified when the tracing state changes.
+   * Could be called from any thread.
+   */
+  size_t registerTracingStateListener(TracingStateListener listener);
+  /**
+   * Unregister previously registered listener with the id returned from
+   * TracingDelegate::registerTracingStateListener().
+   */
+  void unregisterTracingStateListener(size_t subscriptionId);
+
+ private:
+  /**
+   * Covers read / write operations on tracingState_ and subscriptions_.
+   */
+  std::mutex mutex_;
+  /**
+   * Since HostInspectorTarget creates HostTarget, the default value is Disabled.
+   * However, the TracingDelegate is subscribed at the construction of HostTarget, so it will be notified as early as
+   * possible.
+   */
+  TracingState tracingState_ = TracingState::Disabled;
+  /**
+   * Map of subscription ID to listener.
+   */
+  std::unordered_map<size_t, TracingStateListener> subscriptions_;
+  /**
+   * A counter for generating unique subscription IDs.
+   */
+  uint64_t nextSubscriptionId_ = 0;
+  /**
+   * Returns a collection of listeners that are subscribed at the time of the call.
+   * Expected to be only called with mutex_ locked.
+   */
+  std::vector<TracingStateListener> copySubscribedListeners();
+  /**
+   * Notifies specified listeners about the state change.
+   */
+  void notifyListeners(
+      const std::vector<TracingStateListener> &listeners,
+      TracingState state,
+      bool screenshotsCategoryEnabled);
+};
+
 class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTarget>,
                                   public jsinspector_modern::HostTargetDelegate {
  public:
@@ -99,6 +173,26 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
 
   jsinspector_modern::HostTarget *getInspectorTarget();
 
+  /**
+   * Get the current tracing state. Could be called from any thread.
+   */
+  jni::local_ref<JTracingState::javaobject> getTracingState();
+
+  /**
+   * Register a listener that will be notified when the tracing state changes.
+   * Could be called from any thread.
+   *
+   * \return A unique subscription ID to use for unregistering the listener.
+   */
+  jlong registerTracingStateListener(jni::alias_ref<JTracingStateListener::javaobject> listener);
+
+  /**
+   * Unregister a previously registered tracing state listener.
+   *
+   * \param subscriptionId The subscription ID returned from JReactHostInspectorTarget::registerTracingStateListener.
+   */
+  void unregisterTracingStateListener(jlong subscriptionId);
+
   // HostTargetDelegate methods
   jsinspector_modern::HostTargetMetadata getMetadata() override;
   void onReload(const PageReloadRequest &request) override;
@@ -109,6 +203,7 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
       jsinspector_modern::ScopedExecutor<jsinspector_modern::NetworkRequestListener> executor) override;
   std::optional<jsinspector_modern::tracing::TraceRecordingState>
   unstable_getTraceRecordingThatWillBeEmittedOnInitialization() override;
+  jsinspector_modern::HostTargetTracingDelegate *getTracingDelegate() override;
 
  private:
   JReactHostInspectorTarget(
@@ -140,6 +235,10 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
    * CDP session is created.
    */
   std::optional<jsinspector_modern::tracing::TraceRecordingState> stashedTraceRecordingState_;
+  /**
+   * Encapsulates the logic around tracing for this HostInspectorTarget.
+   */
+  std::unique_ptr<TracingDelegate> tracingDelegate_;
 
   friend HybridBase;
 };