react-native-windows 0.80.0 → 0.80.5

package/Shared/DevServerHelper.h

@@ -76,12 +76,20 @@ class DevServerHelper {
       const std::string &packagerHost,
       const uint16_t packagerPort,
       const std::string &deviceName,
-      const std::string &packageName) {
+      const std::string &packageName,
+      const std::string &deviceId) {
     return string_format(
         InspectorDeviceUrlFormat,
         GetDeviceLocalHost(packagerHost, packagerPort).c_str(),
         deviceName.c_str(),
-        packageName.c_str());
+        packageName.c_str(),
+        deviceId.c_str());
+  }
+
+  static std::string
+  get_OpenDebuggerUrl(const std::string &packagerHost, const uint16_t packagerPort, const std::string &deviceId) {
+    return string_format(
+        OpenDebuggerUrlFormat, GetDeviceLocalHost(packagerHost, packagerPort).c_str(), deviceId.c_str());
   }
 
   static constexpr const char DefaultPackagerHost[] = "localhost";
@@ -105,11 +113,13 @@ class DevServerHelper {
   static constexpr const char PackagerConnectionUrlFormat[] = "ws://%s/message";
   static constexpr const char PackagerStatusUrlFormat[] = "http://%s/status";
   static constexpr const char PackagerOpenStackFrameUrlFormat[] = "https://%s/open-stack-frame";
-  static constexpr const char InspectorDeviceUrlFormat[] = "ws://%s/inspector/device?name=%s&app=%s";
+  static constexpr const char InspectorDeviceUrlFormat[] = "ws://%s/inspector/device?name=%s&app=%s&device=%s";
+  static constexpr const char OpenDebuggerUrlFormat[] = "http://%s/open-debugger?device=%s";
 
   static constexpr const char PackagerOkStatus[] = "packager-status:running";
   const int LongPollFailureDelayMs = 5000;
 
+  // TODO: [vmoroz]  avoid using vaiadic args for the format and move it to a utility class.
   template <typename... Args>
   static std::string string_format(const char *format, Args... args) {
     size_t size = snprintf(nullptr, 0, format, args...) + 1;

package/Shared/DevSettings.h

@@ -23,6 +23,10 @@ struct RuntimeHolderLazyInit;
 namespace facebook {
 namespace react {
 
+namespace jsinspector_modern {
+class HostTarget;
+} // namespace jsinspector_modern
+
 enum class JSIEngineOverride : int32_t {
   Default = 0, // No JSI, will use the legacy ExecutorFactory
   Chakra = 1, // Use the JSIExecutorFactory with ChakraRuntime
@@ -117,6 +121,9 @@ struct DevSettings {
 
   // If true, then use only Turbo Modules instead of CxxModules.
   bool useTurboModulesOnly{false};
+
+  // The HostTarget instance for Fusebox
+  facebook::react::jsinspector_modern::HostTarget *inspectorHostTarget;
 };
 
 } // namespace react

package/Shared/DevSupportManager.cpp

@@ -9,14 +9,19 @@
 #include <Shared/DevSettings.h>
 
 #include <Executors/WebSocketJSExecutor.h>
+#include "Inspector/ReactInspectorPackagerConnectionDelegate.h"
 #include "PackagerConnection.h"
 
 #include "Unicode.h"
 #include "Utilities.h"
 
 #include <Utils/CppWinrtLessExceptions.h>
+#include <jsinspector-modern/InspectorFlags.h>
 #include <winrt/Windows.Foundation.h>
+#include <winrt/Windows.Security.Cryptography.Core.h>
+#include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.System.Profile.h>
 #include <winrt/Windows.Web.Http.Filters.h>
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
@@ -171,6 +176,49 @@ bool IsIgnorablePollHResult(HRESULT hr) {
   return hr == WININET_E_INVALID_SERVER_RESPONSE;
 }
 
+std::string GetDeviceId(const std::string &packageName) {
+  const auto hash = winrt::Windows::Security::Cryptography::Core::HashAlgorithmProvider::OpenAlgorithm(
+                        winrt::Windows::Security::Cryptography::Core::HashAlgorithmNames::Sha256())
+                        .CreateHash();
+  hash.Append(winrt::Windows::System::Profile::SystemIdentification::GetSystemIdForPublisher().Id());
+  winrt::Windows::Storage::Streams::InMemoryRandomAccessStream stream;
+  winrt::Windows::Storage::Streams::DataWriter writer;
+  // If an app ID is provided, we will allow reconnection to DevTools.
+  // Apps must supply a unique app ID to each ReactNativeHost instance settings for this to behave correctly.
+  if (!packageName.empty()) {
+    const auto packageNameBuffer = winrt::Windows::Security::Cryptography::CryptographicBuffer::ConvertStringToBinary(
+        winrt::to_hstring(packageName), winrt::Windows::Security::Cryptography::BinaryStringEncoding::Utf16BE);
+    hash.Append(packageNameBuffer);
+  } else {
+    const auto processId = GetCurrentProcessId();
+    std::vector<uint8_t> processIdBytes(
+        reinterpret_cast<const uint8_t *>(&processId), reinterpret_cast<const uint8_t *>(&processId + 1));
+    winrt::array_view<uint8_t> processIdByteArray(processIdBytes);
+    const auto processIdBuffer =
+        winrt::Windows::Security::Cryptography::CryptographicBuffer::CreateFromByteArray(processIdByteArray);
+    hash.Append(processIdBuffer);
+  }
+  const auto hashBuffer = hash.GetValueAndReset();
+  const auto hashString = winrt::Windows::Security::Cryptography::CryptographicBuffer::EncodeToHexString(hashBuffer);
+  return winrt::to_string(hashString);
+}
+
+std::string GetPackageName(const std::string &bundleAppId) {
+  if (!bundleAppId.empty()) {
+    return bundleAppId;
+  }
+
+  std::string packageName{"RNW"};
+  wchar_t fullName[PACKAGE_FULL_NAME_MAX_LENGTH]{};
+  uint32_t size = ARRAYSIZE(fullName);
+  if (SUCCEEDED(GetCurrentPackageFullName(&size, fullName))) {
+    // we are in an unpackaged app
+    packageName = winrt::to_string(fullName);
+  }
+
+  return packageName;
+}
+
 std::future<winrt::Windows::Web::Http::HttpStatusCode> PollForLiveReload(const std::string &url) {
   winrt::Windows::Web::Http::HttpClient httpClient;
   winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
@@ -238,37 +286,48 @@ void DevSupportManager::StopPollingLiveReload() {
   m_cancellation_token = true;
 }
 
-void DevSupportManager::EnsureHermesInspector(
+// TODO: (vmoroz) Use or delete this function
+void DevSupportManager::OpenDevTools(const std::string &bundleAppId) {
+  winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter filter;
+  filter.CacheControl().ReadBehavior(winrt::Windows::Web::Http::Filters::HttpCacheReadBehavior::NoCache);
+  winrt::Windows::Web::Http::HttpClient httpClient(filter);
+  // TODO: Use currently configured dev server host
+  winrt::Windows::Foundation::Uri uri(
+      Microsoft::Common::Unicode::Utf8ToUtf16(facebook::react::DevServerHelper::get_OpenDebuggerUrl(
+          std::string{DevServerHelper::DefaultPackagerHost},
+          DevServerHelper::DefaultPackagerPort,
+          GetDeviceId(GetPackageName(bundleAppId)))));
+
+  winrt::Windows::Web::Http::HttpRequestMessage request(winrt::Windows::Web::Http::HttpMethod::Post(), uri);
+  httpClient.SendRequestAsync(request);
+}
+
+void DevSupportManager::EnsureInspectorPackagerConnection(
     [[maybe_unused]] const std::string &packagerHost,
-    [[maybe_unused]] const uint16_t packagerPort) noexcept {
+    [[maybe_unused]] const uint16_t packagerPort,
+    [[maybe_unused]] const std::string &bundleAppId) noexcept {
   static std::once_flag once;
-  std::call_once(once, [this, &packagerHost, packagerPort]() {
-    // TODO: should we use the bundleAppId as the app param if available?
-    std::string packageName("RNW");
-    wchar_t fullName[PACKAGE_FULL_NAME_MAX_LENGTH]{};
-    UINT32 size = ARRAYSIZE(fullName);
-    if (SUCCEEDED(GetCurrentPackageFullName(&size, fullName))) {
-      // we are in an unpackaged app
-      packageName = winrt::to_string(fullName);
-    }
-
+  std::call_once(once, [this, &packagerHost, packagerPort, &bundleAppId]() {
+    std::string packageName = GetPackageName(bundleAppId);
     std::string deviceName("RNWHost");
     auto hostNames = winrt::Windows::Networking::Connectivity::NetworkInformation::GetHostNames();
     if (hostNames && hostNames.First() && hostNames.First().Current()) {
       deviceName = winrt::to_string(hostNames.First().Current().DisplayName());
     }
 
-    m_inspectorPackagerConnection = std::make_shared<InspectorPackagerConnection>(
-        facebook::react::DevServerHelper::get_InspectorDeviceUrl(packagerHost, packagerPort, deviceName, packageName),
-        m_BundleStatusProvider);
-    m_inspectorPackagerConnection->connectAsync();
+    std::string deviceId = GetDeviceId(packageName);
+    std::string inspectorUrl = facebook::react::DevServerHelper::get_InspectorDeviceUrl(
+        packagerHost, packagerPort, deviceName, packageName, deviceId);
+    jsinspector_modern::InspectorFlags &inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
+    m_inspectorPackagerConnection = std::make_unique<jsinspector_modern::InspectorPackagerConnection>(
+        inspectorUrl,
+        deviceName,
+        packageName,
+        std::make_unique<Microsoft::ReactNative::ReactInspectorPackagerConnectionDelegate>());
+    m_inspectorPackagerConnection->connect();
   });
 }
 
-void DevSupportManager::UpdateBundleStatus(bool isLastDownloadSuccess, int64_t updateTimestamp) noexcept {
-  m_BundleStatusProvider->updateBundleStatus(isLastDownloadSuccess, updateTimestamp);
-}
-
 std::pair<std::string, bool> GetJavaScriptFromServer(
     const std::string &sourceBundleHost,
     const uint16_t sourceBundlePort,

package/Shared/DevSupportManager.h

@@ -14,7 +14,7 @@
 #include <memory>
 #include <string>
 
-#include <InspectorPackagerConnection.h>
+#include <jsinspector-modern/InspectorPackagerConnection.h>
 
 namespace facebook {
 namespace react {
@@ -48,29 +48,17 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
       const uint16_t sourceBundlePort,
       std::function<void()> onChangeCallback) override;
   virtual void StopPollingLiveReload() override;
+  virtual void OpenDevTools(const std::string &bundleAppId) override;
 
-  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
-  virtual void UpdateBundleStatus(bool isLastDownloadSuccess, int64_t updateTimestamp) noexcept override;
+  virtual void EnsureInspectorPackagerConnection(
+      const std::string &packagerHost,
+      const uint16_t packagerPort,
+      const std::string &bundleAppId) noexcept override;
 
  private:
   std::atomic_bool m_cancellation_token;
 
-  std::shared_ptr<InspectorPackagerConnection> m_inspectorPackagerConnection;
-
-  struct BundleStatusProvider : public InspectorPackagerConnection::IBundleStatusProvider {
-    virtual InspectorPackagerConnection::BundleStatus getBundleStatus() {
-      return m_bundleStatus;
-    }
-
-    void updateBundleStatus(bool isLastDownloadSuccess, int64_t updateTimestamp) {
-      m_bundleStatus.m_isLastDownloadSuccess = isLastDownloadSuccess;
-      m_bundleStatus.m_updateTimestamp = updateTimestamp;
-    }
-
-   private:
-    InspectorPackagerConnection::BundleStatus m_bundleStatus;
-  };
-  std::shared_ptr<BundleStatusProvider> m_BundleStatusProvider = std::make_shared<BundleStatusProvider>();
+  std::unique_ptr<facebook::react::jsinspector_modern::InspectorPackagerConnection> m_inspectorPackagerConnection;
 };
 
 } // namespace Microsoft::ReactNative

package/Shared/Hermes/HermesRuntimeAgentDelegate.cpp

@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/*
+ * 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.
+ */
+
+// This file must match the code in React Native folder:
+// ReactCommon/hermes/inspector-modern/chrome/HermesRuntimeAgentDelegate.cpp
+// Unlike the code in React Native sources, this class delegates calls to Hermes C-based API.
+
+#include "HermesRuntimeAgentDelegate.h"
+
+#include <jsinspector-modern/ReactCdp.h>
+
+using namespace facebook::react::jsinspector_modern;
+
+namespace Microsoft::ReactNative {
+
+namespace {
+
+struct HermesStateWrapper : public RuntimeAgentDelegate::ExportedState {
+  explicit HermesStateWrapper(HermesUniqueCdpState &&hermesCdpState) : hermesCdpState_(std::move(hermesCdpState)) {}
+
+  static HermesUniqueCdpState unwrapDestructively(ExportedState *wrapper) {
+    if (!wrapper) {
+      return {};
+    }
+    if (auto *typedWrapper = dynamic_cast<HermesStateWrapper *>(wrapper)) {
+      return std::move(typedWrapper->hermesCdpState_);
+    }
+    return {};
+  }
+
+ private:
+  HermesUniqueCdpState hermesCdpState_;
+};
+
+} // namespace
+
+HermesRuntimeAgentDelegate::HermesRuntimeAgentDelegate(
+    FrontendChannel frontendChannel,
+    SessionState &sessionState,
+    std::unique_ptr<RuntimeAgentDelegate::ExportedState> previouslyExportedState,
+    const ExecutionContextDescription &executionContextDescription,
+    hermes_runtime runtime,
+    HermesRuntimeTargetDelegate &runtimeTargetDelegate,
+    facebook::react::RuntimeExecutor runtimeExecutor)
+    : hermesCdpAgent_(HermesInspectorApi::createCdpAgent(
+          runtimeTargetDelegate.getCdpDebugApi(),
+          executionContextDescription.id,
+          // Adapt std::function<void(std::function<void(jsi::Runtime& runtime)>&& callback)>
+          // to hermes_enqueue_runtime_task_functor
+          AsFunctor<hermes_enqueue_runtime_task_functor>(
+              [runtimeExecutor = std::move(runtimeExecutor), runtime](hermes_run_runtime_task_functor runtimeTask) {
+                // Adapt std::function<void(jsi::Runtime& runtime)> to hermes_runtime_task_functor
+                runtimeExecutor(
+                    [runtime, fn = std::make_shared<FunctorWrapper<hermes_run_runtime_task_functor>>(runtimeTask)](
+                        facebook::jsi::Runtime &rt) { (*fn)(runtime); });
+              }),
+          // Adapt void(const char *json_utf8, size_t json_size) to std::function<void(std::string_view)>
+          AsFunctor<hermes_enqueue_frontend_message_functor>(
+              [frontendChannel = std::move(frontendChannel)](const char *json_utf8, size_t json_size) {
+                frontendChannel(std::string_view(json_utf8, json_size));
+              }),
+          HermesStateWrapper::unwrapDestructively(previouslyExportedState.get()).release())) {
+  // Enable domains conditionally based on session state
+  // This matches the iOS/Android implementation pattern:
+  // Domains are enabled in response to Chrome DevTools sending Runtime.enable/Debugger.enable
+  if (sessionState.isRuntimeDomainEnabled) {
+    HermesInspectorApi::enableRuntimeDomain(hermesCdpAgent_.get());
+  }
+  if (sessionState.isDebuggerDomainEnabled) {
+    HermesInspectorApi::enableDebuggerDomain(hermesCdpAgent_.get());
+  }
+}
+
+HermesRuntimeAgentDelegate::~HermesRuntimeAgentDelegate() = default;
+
+bool HermesRuntimeAgentDelegate::handleRequest(const cdp::PreparsedRequest &req) {
+  if (req.method.starts_with("Log.")) {
+    // Since we know Hermes doesn't do anything useful with Log messages,
+    // but our containing HostAgent will, bail out early.
+    return false;
+  }
+
+  std::string json = req.toJson();
+  HermesInspectorApi::handleCommand(hermesCdpAgent_.get(), json.c_str(), json.size());
+  return true;
+}
+
+std::unique_ptr<RuntimeAgentDelegate::ExportedState> HermesRuntimeAgentDelegate::getExportedState() {
+  return std::make_unique<HermesStateWrapper>(HermesInspectorApi::getCdpState(hermesCdpAgent_.get()));
+}
+
+} // namespace Microsoft::ReactNative

package/Shared/Hermes/HermesRuntimeAgentDelegate.h

@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+/*
+ * 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.
+ */
+
+// This file must match the code in React Native folder:
+// ReactCommon/hermes/inspector-modern/chrome/HermesRuntimeAgentDelegate.h
+// Unlike the code in React Native sources, this class delegates calls to Hermes C-based API.
+// We use different namespace for this class comparing with the RN code.
+
+#pragma once
+
+#include "HermesRuntimeTargetDelegate.h"
+
+#include <ReactCommon/RuntimeExecutor.h>
+#include <jsinspector-modern/ReactCdp.h>
+#include "HermesRuntimeHolder.h"
+
+namespace Microsoft::ReactNative {
+
+// A RuntimeAgentDelegate that handles requests from the Chrome DevTools
+// Protocol for an instance of Hermes, using the modern CDPAgent API.
+class HermesRuntimeAgentDelegate : public facebook::react::jsinspector_modern::RuntimeAgentDelegate {
+ public:
+  /**
+   * \param frontendChannel A channel used to send responses and events to the
+   * frontend.
+   * \param sessionState The state of the current CDP session. This will only
+   * be accessed on the main thread (during the constructor, in handleRequest,
+   * etc).
+   * \param previouslyExportedState The exported state from a previous instance
+   * of RuntimeAgentDelegate (NOT necessarily HermesRuntimeAgentDelegate).
+   * This may be nullptr, and if not nullptr it may be of any concrete type that
+   * implements RuntimeAgentDelegate::ExportedState.
+   * \param executionContextDescription A description of the execution context
+   * represented by this runtime. This is used for disambiguating the
+   * source/destination of CDP messages when there are multiple runtimes
+   * (concurrently or over the life of a Host).
+   * \param hermes_runtime The Hermes runtime that this agent is attached to. The caller
+   * is responsible for keeping this object alive for the duration of the
+   * \c HermesRuntimeAgentDelegate lifetime.
+   * \param runtimeTargetDelegate The \c HermesRuntimeTargetDelegate object
+   * object for the passed runtime.
+   * \param runtimeExecutor A callback for scheduling work on the JS thread.
+   * \c runtimeExecutor may drop scheduled work if the runtime is destroyed
+   * first.
+   */
+  HermesRuntimeAgentDelegate(
+      facebook::react::jsinspector_modern::FrontendChannel frontendChannel,
+      facebook::react::jsinspector_modern::SessionState &sessionState,
+      std::unique_ptr<facebook::react::jsinspector_modern::RuntimeAgentDelegate::ExportedState> previouslyExportedState,
+      const facebook::react::jsinspector_modern::ExecutionContextDescription &executionContextDescription,
+      hermes_runtime runtime,
+      HermesRuntimeTargetDelegate &runtimeTargetDelegate,
+      facebook::react::RuntimeExecutor runtimeExecutor);
+
+  ~HermesRuntimeAgentDelegate() override;
+
+ public: // RuntimeAgentDelegate implementation
+  /**
+   * Handle a CDP request. The response will be sent over the provided
+   * \c FrontendChannel synchronously or asynchronously.
+   * \param req The parsed request.
+   * \returns true if this agent has responded, or will respond asynchronously,
+   * to the request (with either a success or error message). False if the
+   * agent expects another agent to respond to the request instead.
+   */
+  bool handleRequest(const facebook::react::jsinspector_modern::cdp::PreparsedRequest &req) override;
+
+  std::unique_ptr<RuntimeAgentDelegate::ExportedState> getExportedState() override;
+
+ private:
+  HermesUniqueCdpAgent hermesCdpAgent_;
+};
+
+} // namespace Microsoft::ReactNative