react-native-windows 0.68.1 → 0.69.0-preview.1

package/Shared/DevSupportManager.cpp

@@ -33,6 +33,9 @@
 #pragma warning(pop)
 
 #include <future>
+#include <mutex>
+
+#include <AppModel.h>
 
 #if _MSC_VER <= 1913
 // VC 19 (2015-2017.6) cannot optimize co_await/cppwinrt usage
@@ -67,13 +70,13 @@ std::future<std::pair<std::string, bool>> GetJavaScriptFromServerAsync(const std
 
   HRESULT hr = asyncRequest.ErrorCode();
   if (FAILED(hr)) {
-    std::ostringstream sstream;
+    std::string error;
     if (hr == WININET_E_CANNOT_CONNECT) {
-      sstream << "A connection with the server " << url << " could not be established\n\nIs the packager running?";
+      error = fmt::format("A connection with the server {} could not be established.\n\nIs the packager running?", url);
     } else {
-      sstream << "Error " << std::hex << static_cast<int>(asyncRequest.ErrorCode()) << " downloading " << url;
+      error = fmt::format("Error 0x{:x} downloading {}.", static_cast<int>(asyncRequest.ErrorCode()), url);
     }
-    co_return std::make_pair(sstream.str(), false);
+    co_return std::make_pair(error, false);
   }
 
   winrt::Windows::Web::Http::HttpResponseMessage response = asyncRequest.GetResults();
@@ -86,15 +89,15 @@ std::future<std::pair<std::string, bool>> GetJavaScriptFromServerAsync(const std
   uint32_t len = reader.UnconsumedBufferLength();
   std::string result;
   if (len > 0 || response.IsSuccessStatusCode()) {
-    std::vector<uint8_t> data;
-    data.resize(len);
-    reader.ReadBytes(winrt::array_view(data.data(), data.data() + len));
+    std::string data;
     data.resize(len);
-    result = std::string(data.begin(), data.end());
+    auto buf = reinterpret_cast<uint8_t *>(data.data());
+    static_assert(
+        sizeof(buf[0]) == sizeof(data[0]), "perf optimization relies on uint8_t and char being the same size");
+    reader.ReadBytes(winrt::array_view(buf, buf + len));
+    result = std::move(data);
   } else {
-    std::ostringstream sstream;
-    sstream << "HTTP Error " << static_cast<int>(response.StatusCode()) << " downloading " << url;
-    result = sstream.str();
+    result = fmt::format("HTTP Error {} downloading {}.", static_cast<int>(response.StatusCode()), url);
   }
 
   co_return std::make_pair(std::move(result), response.IsSuccessStatusCode());
@@ -237,34 +240,32 @@ void DevSupportManager::StopPollingLiveReload() {
   m_cancellation_token = true;
 }
 
-void DevSupportManager::StartInspector(
+void DevSupportManager::EnsureHermesInspector(
     [[maybe_unused]] const std::string &packagerHost,
     [[maybe_unused]] const uint16_t packagerPort) noexcept {
 #ifdef HERMES_ENABLE_DEBUGGER
-  std::string packageName("RNW");
-  if (auto currentPackage = winrt::Windows::ApplicationModel::Package::Current()) {
-    packageName = winrt::to_string(currentPackage.DisplayName());
-  }
+  static std::once_flag once;
+  std::call_once(once, [this, &packagerHost, packagerPort]() {
+    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::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());
-  }
+    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();
-#endif
-}
+    m_inspectorPackagerConnection = std::make_shared<InspectorPackagerConnection>(
+        facebook::react::DevServerHelper::get_InspectorDeviceUrl(packagerHost, packagerPort, deviceName, packageName),
+        m_BundleStatusProvider);
+    m_inspectorPackagerConnection->connectAsync();
+  });
 
-void DevSupportManager::StopInspector() noexcept {
-#ifdef HERMES_ENABLE_DEBUGGER
-  if (m_inspectorPackagerConnection) {
-    m_inspectorPackagerConnection->disconnectAsync();
-    m_inspectorPackagerConnection = nullptr;
-  }
 #endif
 }
 

package/Shared/DevSupportManager.h

@@ -50,8 +50,7 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
       std::function<void()> onChangeCallback) override;
   virtual void StopPollingLiveReload() override;
 
-  virtual void StartInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
-  virtual void StopInspector() noexcept override;
+  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
   virtual void UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept override;
 
  private:

package/Shared/HermesRuntimeHolder.cpp

@@ -74,7 +74,15 @@ class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::R
 } // namespace
 
 void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  HermesShim::hermesCrashHandler(static_cast<facebook::hermes::HermesRuntime &>(*m_runtime), fileDescriptor);
+  HermesShim::hermesCrashHandler(*m_hermesRuntime, fileDescriptor);
+}
+
+void HermesRuntimeHolder::teardown() noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
+  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
+    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
+  }
+#endif
 }
 
 facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
@@ -84,43 +92,44 @@ facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcep
 std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
   std::call_once(m_once_flag, [this]() { initRuntime(); });
 
-  if (!m_runtime)
+  if (!m_hermesRuntime)
     std::terminate();
 
   // Make sure that the runtime instance is not consumed from multiple threads.
   if (m_own_thread_id != std::this_thread::get_id())
     std::terminate();
 
-  return m_runtime;
+  return m_hermesRuntime;
 }
 
 HermesRuntimeHolder::HermesRuntimeHolder(
     std::shared_ptr<facebook::react::DevSettings> devSettings,
     std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept
-    : m_devSettings(std::move(devSettings)), m_jsQueue(std::move(jsQueue)) {}
+    : m_weakDevSettings(devSettings), m_jsQueue(std::move(jsQueue)) {}
 
 void HermesRuntimeHolder::initRuntime() noexcept {
-  auto hermesRuntime = makeHermesRuntimeSystraced(m_devSettings->enableDefaultCrashHandler);
-
-  facebook::hermes::HermesRuntime &hermesRuntimeRef = *hermesRuntime;
+  auto devSettings = m_weakDevSettings.lock();
+  if (!devSettings)
+    std::terminate();
 
-  m_runtime = std::move(hermesRuntime);
+  m_hermesRuntime = makeHermesRuntimeSystraced(devSettings->enableDefaultCrashHandler);
   m_own_thread_id = std::this_thread::get_id();
 
 #ifdef HERMES_ENABLE_DEBUGGER
-  if (m_devSettings->useDirectDebugger) {
-    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_runtime, hermesRuntimeRef, m_jsQueue);
+  if (devSettings->useDirectDebugger) {
+    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_hermesRuntime, *m_hermesRuntime, m_jsQueue);
     facebook::hermes::inspector::chrome::enableDebugging(
         std::move(adapter),
-        m_devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : m_devSettings->debuggerRuntimeName);
+        devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : devSettings->debuggerRuntimeName);
   }
 #endif
 
   // Add js engine information to Error.prototype so in error reporting we
   // can send this information.
-  auto errorPrototype =
-      m_runtime->global().getPropertyAsObject(*m_runtime, "Error").getPropertyAsObject(*m_runtime, "prototype");
-  errorPrototype.setProperty(*m_runtime, "jsEngine", "hermes");
+  auto errorPrototype = m_hermesRuntime->global()
+                            .getPropertyAsObject(*m_hermesRuntime, "Error")
+                            .getPropertyAsObject(*m_hermesRuntime, "prototype");
+  errorPrototype.setProperty(*m_hermesRuntime, "jsEngine", "hermes");
 }
 
 } // namespace react

package/Shared/HermesRuntimeHolder.h

@@ -9,6 +9,10 @@
 
 #include <DevSettings.h>
 
+namespace facebook::hermes {
+class HermesRuntime;
+}
+
 namespace facebook {
 namespace react {
 
@@ -19,18 +23,20 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
 
   void crashHandler(int fileDescriptor) noexcept override;
 
+  void teardown() noexcept override;
+
   HermesRuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,
       std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept;
 
  private:
   void initRuntime() noexcept;
-  std::shared_ptr<facebook::jsi::Runtime> m_runtime;
+  std::shared_ptr<facebook::hermes::HermesRuntime> m_hermesRuntime;
 
   std::once_flag m_once_flag;
   std::thread::id m_own_thread_id;
 
-  std::shared_ptr<facebook::react::DevSettings> m_devSettings;
+  std::weak_ptr<facebook::react::DevSettings> m_weakDevSettings;
   std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
 };
 

package/Shared/IDevSupportManager.h

@@ -22,8 +22,7 @@ struct IDevSupportManager {
       std::function<void()> onChangeCallback) = 0;
   virtual void StopPollingLiveReload() = 0;
 
-  virtual void StartInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
-  virtual void StopInspector() noexcept = 0;
+  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
   virtual void UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept = 0;
 };
 

package/Shared/InspectorPackagerConnection.cpp

@@ -196,7 +196,8 @@ InspectorPackagerConnection::InspectorPackagerConnection(
 winrt::fire_and_forget InspectorPackagerConnection::disconnectAsync() {
   co_await winrt::resume_background();
   std::string reason("Explicit close");
-  m_packagerWebSocketConnection->Close(Microsoft::React::WinRTWebSocketResource::CloseCode::GoingAway, reason);
+  m_packagerWebSocketConnection->Close(
+      Microsoft::React::Networking::WinRTWebSocketResource::CloseCode::GoingAway, reason);
   co_return;
 }
 
@@ -204,9 +205,10 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
   co_await winrt::resume_background();
 
   std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> certExceptions;
-  m_packagerWebSocketConnection = std::make_shared<Microsoft::React::WinRTWebSocketResource>(std::move(certExceptions));
+  m_packagerWebSocketConnection =
+      std::make_shared<Microsoft::React::Networking::WinRTWebSocketResource>(std::move(certExceptions));
 
-  m_packagerWebSocketConnection->SetOnError([](const Microsoft::React::IWebSocketResource::Error &err) {
+  m_packagerWebSocketConnection->SetOnError([](const Microsoft::React::Networking::IWebSocketResource::Error &err) {
     facebook::react::tracing::error(err.Message.c_str());
   });
 
@@ -267,8 +269,8 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
         }
       });
 
-  Microsoft::React::IWebSocketResource::Protocols protocols;
-  Microsoft::React::IWebSocketResource::Options options;
+  Microsoft::React::Networking::IWebSocketResource::Protocols protocols;
+  Microsoft::React::Networking::IWebSocketResource::Options options;
   m_packagerWebSocketConnection->Connect(std::string{m_url}, protocols, options);
 
   co_return;

package/Shared/InspectorPackagerConnection.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include <InspectorProxy.h>
-#include <WinRTWebSocketResource.h>
+#include <Networking/WinRTWebSocketResource.h>
 #include <jsinspector/InspectorInterfaces.h>
 
 namespace Microsoft::ReactNative {
@@ -42,7 +42,7 @@ class InspectorPackagerConnection final : public std::enable_shared_from_this<In
   void sendMessageToVM(int64_t pageId, std::string &&message);
 
   std::unordered_map<int64_t, std::unique_ptr<facebook::react::ILocalConnection>> m_localConnections;
-  std::shared_ptr<Microsoft::React::WinRTWebSocketResource> m_packagerWebSocketConnection;
+  std::shared_ptr<Microsoft::React::Networking::WinRTWebSocketResource> m_packagerWebSocketConnection;
   std::shared_ptr<IBundleStatusProvider> m_bundleStatusProvider;
   std::string m_url;
 };

package/Shared/JSI/ChakraApi.cpp

@@ -3,7 +3,6 @@
 
 #include "ChakraApi.h"
 
-#include <RuntimeOptions.h>
 #include <sstream>
 #include <utility>
 #include "Unicode.h"

package/Shared/JSI/ChakraRuntime.cpp

@@ -4,7 +4,6 @@
 #include "ChakraRuntime.h"
 #include "ChakraRuntimeFactory.h"
 
-#include <RuntimeOptions.h>
 #include "Unicode.h"
 #include "Utilities.h"
 
@@ -991,7 +990,7 @@ size_t ChakraRuntime::JsiValueViewArgs::Size() const noexcept {
 
 ChakraRuntime::PropNameIDView::PropNameIDView(JsPropertyIdRef propertyId) noexcept
     : m_propertyId{
-          make<facebook::jsi::PropNameID>(new (std::addressof(m_pointerStore)) ChakraPointerValueView(propertyId))} {}
+          make<facebook::jsi::PropNameID>(new(std::addressof(m_pointerStore)) ChakraPointerValueView(propertyId))} {}
 
 ChakraRuntime::PropNameIDView::~PropNameIDView() noexcept {}
 

package/Shared/JSI/NapiJsiV8RuntimeHolder.h

@@ -22,7 +22,7 @@ class NapiJsiV8RuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
       std::unique_ptr<facebook::jsi::PreparedScriptStore> &&preparedScriptStore) noexcept;
 
  private:
-  static void ScheduleTaskCallback(
+  static void __cdecl ScheduleTaskCallback(
       napi_env env,
       napi_ext_task_callback taskCb,
       void *taskData,

package/Shared/JSI/RuntimeHolder.h

@@ -18,6 +18,8 @@ struct RuntimeHolderLazyInit {
   virtual std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept = 0;
   virtual facebook::react::JSIEngineOverride getRuntimeType() noexcept = 0;
 
+  virtual void teardown() noexcept {};
+
   // You can call this when a crash happens to attempt recording additional data
   // The fd supplied is a raw file stream an implementation might write JSON to
   virtual void crashHandler(int fileDescriptor) noexcept {};

package/Shared/Modules/HttpModule.cpp

@@ -0,0 +1,198 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "HttpModule.h"
+
+// React Native
+#include <cxxreact/Instance.h>
+#include <cxxreact/JsArgumentHelpers.h>
+
+using facebook::react::Instance;
+using folly::dynamic;
+using std::shared_ptr;
+using std::string;
+using std::weak_ptr;
+
+namespace {
+
+using Microsoft::React::Networking::IHttpResource;
+
+constexpr char moduleName[] = "Networking";
+
+static void SendEvent(weak_ptr<Instance> weakReactInstance, string &&eventName, dynamic &&args) {
+  if (auto instance = weakReactInstance.lock()) {
+    instance->callJSFunction("RCTDeviceEventEmitter", "emit", dynamic::array(std::move(eventName), std::move(args)));
+  }
+}
+
+static shared_ptr<IHttpResource> CreateHttpResource(weak_ptr<Instance> weakReactInstance) {
+  auto resource = IHttpResource::Make();
+
+  resource->SetOnResponse([weakReactInstance](int64_t requestId, IHttpResource::Response &&response) {
+    dynamic headers = dynamic::object();
+    for (auto &header : response.Headers) {
+      headers[header.first] = header.second;
+    }
+
+    // TODO: Test response content.
+    dynamic args = dynamic::array(requestId, response.StatusCode, headers, response.Url);
+
+    SendEvent(weakReactInstance, "didReceiveNetworkResponse", std::move(args));
+  });
+
+  resource->SetOnData([weakReactInstance](int64_t requestId, std::string &&responseData) {
+    dynamic args = dynamic::array(requestId, std::move(responseData));
+
+    SendEvent(weakReactInstance, "didReceiveNetworkData", std::move(args));
+
+    // TODO: Move into separate method IF not executed right after onData()
+    SendEvent(weakReactInstance, "didCompleteNetworkResponse", dynamic::array(requestId));
+  });
+
+  resource->SetOnError([weakReactInstance](int64_t requestId, string &&message) {
+    dynamic args = dynamic::array(requestId, std::move(message));
+    // TODO: isTimeout errorArgs.push_back(true);
+
+    SendEvent(weakReactInstance, "didCompleteNetworkResponse", std::move(args));
+  });
+
+  return resource;
+}
+
+} // namespace
+
+namespace Microsoft::React {
+
+HttpModule::HttpModule() noexcept : m_holder{std::make_shared<ModuleHolder>()} {
+  m_holder->Module = this;
+}
+
+HttpModule::~HttpModule() noexcept /*override*/ {
+  m_holder->Module = nullptr;
+}
+
+#pragma region CxxModule
+
+string HttpModule::getName() /*override*/ {
+  return moduleName;
+}
+
+std::map<string, dynamic> HttpModule::getConstants() {
+  return {};
+}
+
+// clang-format off
+std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods() {
+
+  auto weakHolder = weak_ptr<ModuleHolder>(m_holder);
+  auto holder = weakHolder.lock();
+  auto weakReactInstance = weak_ptr<Instance>(holder->Module->getInstance());
+
+  return
+  {
+    {
+      "sendRequest",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args, Callback cxxCallback)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder) {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        {
+          IHttpResource::BodyData bodyData;
+          auto params = facebook::xplat::jsArgAsObject(args, 0);
+          auto data = params["data"];
+          auto stringData = data["string"];
+          if (!stringData.empty())
+          {
+            bodyData = {IHttpResource::BodyData::Type::String, stringData.getString()};
+          }
+          else
+          {
+            auto base64Data = data["base64"];
+            if (!base64Data.empty())
+            {
+              bodyData = {IHttpResource::BodyData::Type::Base64, base64Data.getString()};
+            }
+            else
+            {
+              auto uriData = data["uri"];
+              if (!uriData.empty())
+              {
+                bodyData = {IHttpResource::BodyData::Type::Uri, uriData.getString()};
+              }
+            }
+          }
+          //TODO: Support FORM data
+
+          IHttpResource::Headers headers;
+          for (auto& header : params["headers"].items()) {
+            headers.emplace(header.first.getString(), header.second.getString());
+          }
+
+          resource->SendRequest(
+            params["method"].asString(),
+            params["url"].asString(),
+            std::move(headers),
+            std::move(bodyData),
+            params["responseType"].asString(),
+            params["incrementalUpdates"].asBool(),
+            static_cast<int64_t>(params["timeout"].asDouble()),
+            false,//withCredentials,
+            [cxxCallback = std::move(cxxCallback)](int64_t requestId) {
+              cxxCallback({requestId});
+            }
+          );
+        } // If resource available
+      }
+    },
+    {
+      "abortRequest",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder)
+        {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        {
+          resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
+        }
+      }
+    },
+    {
+      "clearCookies",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder)
+        {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        {
+          resource->ClearCookies();
+        }
+      }
+    }
+  };
+}
+// clang-format on
+
+#pragma endregion CxxModule
+
+/*extern*/ const char *GetHttpModuleName() noexcept {
+  return moduleName;
+}
+
+} // namespace Microsoft::React

package/Shared/Modules/HttpModule.h

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Networking/IHttpResource.h>
+
+// React Native
+#include <cxxreact/CxxModule.h>
+
+namespace Microsoft::React {
+
+///
+/// Realizes <c>NativeModules</c> projection.
+/// <remarks>See src\Libraries\Network\RCTNetworkingWinShared.js</remarks>
+///
+class HttpModule : public facebook::xplat::module::CxxModule {
+ public:
+  enum MethodId { SendRequest = 0, AbortRequest = 1, ClearCookies = 2, LAST = ClearCookies };
+
+  HttpModule() noexcept;
+
+  ~HttpModule() noexcept override;
+
+#pragma region CxxModule
+
+  /// <summary>
+  /// <see cref="facebook::xplat::module::CxxModule::getName" />
+  /// </summary>
+  std::string getName() override;
+
+  /// <summary>
+  /// <see cref="facebook::xplat::module::CxxModule::getConstants" />
+  /// </summary>
+  std::map<std::string, folly::dynamic> getConstants() override;
+
+  /// <summary>
+  /// <see cref="facebook::xplat::module::CxxModule::getMethods" />
+  /// </summary>
+  /// <remarks>See See react-native/Libraries/WebSocket/WebSocket.js</remarks>
+  std::vector<Method> getMethods() override;
+
+#pragma endregion CxxModule
+
+ private:
+  struct ModuleHolder {
+    HttpModule *Module{nullptr};
+  };
+
+  std::shared_ptr<Networking::IHttpResource> m_resource;
+  std::shared_ptr<ModuleHolder> m_holder;
+};
+} // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.cpp

@@ -26,8 +26,8 @@ using std::string;
 using std::weak_ptr;
 
 namespace {
-using Microsoft::React::IWebSocketResource;
 using Microsoft::React::WebSocketModule;
+using Microsoft::React::Networking::IWebSocketResource;
 
 constexpr char moduleName[] = "WebSocketModule";
 
@@ -246,6 +246,10 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
 } // getMethods
 // clang-format on
 
+/*extern*/ const char *GetWebSocketModuleName() noexcept {
+  return moduleName;
+}
+
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule() noexcept {
   return std::make_unique<WebSocketModule>();
 }

package/Shared/Modules/WebSocketModule.h

@@ -3,8 +3,10 @@
 
 #pragma once
 
+#include <Networking/IWebSocketResource.h>
+
+// React Native
 #include <cxxreact/CxxModule.h>
-#include "IWebSocketResource.h"
 
 namespace Microsoft::React {
 
@@ -25,12 +27,12 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
     /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
     /// As defined in WebSocket.js.
     /// </summary>
-    std::map<int64_t, std::shared_ptr<IWebSocketResource>> ResourceMap{};
+    std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> ResourceMap{};
 
     /// <summary>
     /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
     /// </summary>
-    std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> ResourceFactory;
+    std::function<std::shared_ptr<Networking::IWebSocketResource>(std::string &&)> ResourceFactory;
 
     /// <summary>
     /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
@@ -58,14 +60,15 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
 
 #pragma endregion CxxModule overrides
 
-  void SetResourceFactory(std::function<std::shared_ptr<IWebSocketResource>(const std::string &)> &&resourceFactory);
+  void SetResourceFactory(
+      std::function<std::shared_ptr<Networking::IWebSocketResource>(const std::string &)> &&resourceFactory);
 
  private:
   /// <summary>
   /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
   /// As defined in WebSocket.js.
   /// </summary>
-  std::map<int64_t, std::shared_ptr<IWebSocketResource>> m_webSockets;
+  std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> m_webSockets;
 
   /// <summary>
   /// Keeps members that can be accessed threads other than this module's owner accessible.