react-native-windows 0.67.0-preview.5 → 0.67.1

package/Shared/JSI/NapiJsiV8RuntimeHolder.cpp

@@ -96,7 +96,11 @@ void NapiJsiV8RuntimeHolder::InitRuntime() noexcept {
   m_ownThreadId = std::this_thread::get_id();
 }
 
-#pragma region facebook::jsi::RuntimeHolderLazyInit
+#pragma region Microsoft::JSI::RuntimeHolderLazyInit
+
+facebook::react::JSIEngineOverride NapiJsiV8RuntimeHolder::getRuntimeType() noexcept {
+  return facebook::react::JSIEngineOverride::V8NodeApi;
+}
 
 shared_ptr<Runtime> NapiJsiV8RuntimeHolder::getRuntime() noexcept /*override*/
 {
@@ -112,6 +116,6 @@ shared_ptr<Runtime> NapiJsiV8RuntimeHolder::getRuntime() noexcept /*override*/
   return m_runtime;
 }
 
-#pragma endregion facebook::jsi::RuntimeHolderLazyInit
+#pragma endregion Microsoft::JSI::RuntimeHolderLazyInit
 
 } // namespace Microsoft::JSI

package/Shared/JSI/NapiJsiV8RuntimeHolder.h

@@ -10,9 +10,10 @@
 
 namespace Microsoft::JSI {
 
-class NapiJsiV8RuntimeHolder : public facebook::jsi::RuntimeHolderLazyInit {
+class NapiJsiV8RuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
  public:
   std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
+  facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
 
   NapiJsiV8RuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,

package/Shared/JSI/RuntimeHolder.h

@@ -3,8 +3,9 @@
 #include <jsi/jsi.h>
 #include <memory>
 
-namespace facebook {
-namespace jsi {
+#include <DevSettings.h>
+
+namespace Microsoft::JSI {
 
 // An instance of this interface is expected to
 // a. lazily create a JSI Runtime on the first call to getRuntime
@@ -15,7 +16,7 @@ namespace jsi {
 
 struct RuntimeHolderLazyInit {
   virtual std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept = 0;
+  virtual facebook::react::JSIEngineOverride getRuntimeType() noexcept = 0;
 };
 
-} // namespace jsi
-} // namespace facebook
+} // namespace Microsoft::JSI

package/Shared/Modules/WebSocketModule.cpp

@@ -14,7 +14,9 @@
 #include <iomanip>
 
 using namespace facebook::xplat;
-using namespace folly;
+
+using facebook::react::Instance;
+using folly::dynamic;
 
 using Microsoft::Common::Unicode::Utf16ToUtf8;
 using Microsoft::Common::Unicode::Utf8ToUtf16;
@@ -24,17 +26,111 @@ using std::string;
 using std::weak_ptr;
 
 namespace {
+using Microsoft::React::IWebSocketResource;
+using Microsoft::React::WebSocketModule;
+
 constexpr char moduleName[] = "WebSocketModule";
+
+static void SendEvent(weak_ptr<Instance> weakInstance, string &&eventName, dynamic &&args) {
+  if (auto instance = weakInstance.lock()) {
+    instance->callJSFunction("RCTDeviceEventEmitter", "emit", dynamic::array(std::move(eventName), std::move(args)));
+  }
+}
+
+static shared_ptr<IWebSocketResource>
+GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedState> weakState) {
+  auto state = weakState.lock();
+  if (!state) {
+    return nullptr;
+  }
+
+  auto itr = state->ResourceMap.find(id);
+  if (itr == state->ResourceMap.end()) {
+    if (!state->Module) {
+      return nullptr;
+    }
+    auto weakInstance = state->Module->getInstance();
+
+    shared_ptr<IWebSocketResource> ws;
+    try {
+      ws = state->ResourceFactory(std::move(url));
+    } catch (const winrt::hresult_error &e) {
+      std::stringstream ss;
+      ss << "[" << std::hex << std::showbase << std::setw(8) << static_cast<uint32_t>(e.code()) << "] "
+         << winrt::to_string(e.message());
+
+      SendEvent(weakInstance, "webSocketFailed", dynamic::object("id", id)("message", std::move(ss.str())));
+
+      return nullptr;
+    } catch (const std::exception &e) {
+      SendEvent(weakInstance, "webSocketFailed", dynamic::object("id", id)("message", e.what()));
+
+      return nullptr;
+    } catch (...) {
+      SendEvent(
+          weakInstance,
+          "webSocketFailed",
+          dynamic::object("id", id)("message", "Unidentified error creating IWebSocketResource"));
+
+      return nullptr;
+    }
+
+    ws->SetOnError([id, weakInstance](const IWebSocketResource::Error &err) {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto errorObj = dynamic::object("id", id)("message", err.Message);
+      SendEvent(weakInstance, "websocketFailed", std::move(errorObj));
+    });
+    ws->SetOnConnect([id, weakInstance]() {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto args = dynamic::object("id", id);
+      SendEvent(weakInstance, "websocketOpen", std::move(args));
+    });
+    ws->SetOnMessage([id, weakInstance](size_t length, const string &message, bool isBinary) {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto args = dynamic::object("id", id)("data", message)("type", isBinary ? "binary" : "text");
+      SendEvent(weakInstance, "websocketMessage", std::move(args));
+    });
+    ws->SetOnClose([id, weakInstance](IWebSocketResource::CloseCode code, const string &reason) {
+      auto strongInstance = weakInstance.lock();
+      if (!strongInstance)
+        return;
+
+      auto args = dynamic::object("id", id)("code", static_cast<uint16_t>(code))("reason", reason);
+      SendEvent(weakInstance, "websocketClosed", std::move(args));
+    });
+
+    state->ResourceMap.emplace(id, ws);
+    return ws;
+  }
+
+  return itr->second;
+}
+
 } // anonymous namespace
 
 namespace Microsoft::React {
 
-WebSocketModule::WebSocketModule()
-    : m_resourceFactory{[](string &&url) { return IWebSocketResource::Make(std::move(url)); }} {}
+WebSocketModule::WebSocketModule() : m_sharedState{std::make_shared<SharedState>()} {
+  m_sharedState->ResourceFactory = [](string &&url) { return IWebSocketResource::Make(); };
+  m_sharedState->Module = this;
+}
+
+WebSocketModule::~WebSocketModule() noexcept /*override*/ {
+  m_sharedState->Module = nullptr;
+}
 
 void WebSocketModule::SetResourceFactory(
     std::function<shared_ptr<IWebSocketResource>(const string &)> &&resourceFactory) {
-  m_resourceFactory = std::move(resourceFactory);
+  m_sharedState->ResourceFactory = std::move(resourceFactory);
 }
 
 string WebSocketModule::getName() {
@@ -50,9 +146,9 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
 {
   return
   {
-    Method(
+    {
       "connect",
-      [this](dynamic args) // const string& url, dynamic protocols, dynamic options, int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& url, dynamic protocols, dynamic options, int64_t id
       {
         IWebSocketResource::Protocols protocols;
         dynamic protocolsDynamic = jsArgAsDynamic(args, 1);
@@ -75,20 +171,21 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
           }
         }
 
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 3), jsArgAsString(args, 0));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 3), jsArgAsString(args, 0), weakState);
         if (auto sharedWs = weakWs.lock())
         {
-          sharedWs->Connect(protocols, options);
+          sharedWs->Connect(jsArgAsString(args, 0), protocols, options);
         }
-      }),
-    Method(
+      }
+    },
+    {
       "close",
-      [this](dynamic args) // [int64_t code, string reason,] int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // [int64_t code, string reason,] int64_t id
       {
         // See react-native\Libraries\WebSocket\WebSocket.js:_close
         if (args.size() == 3) // WebSocketModule.close(statusCode, closeReason, this._socketId);
         {
-          weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 2));
+          weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 2), {}, weakState);
           if (auto sharedWs = weakWs.lock())
           {
             sharedWs->Close(static_cast<IWebSocketResource::CloseCode>(jsArgAsInt(args, 0)), jsArgAsString(args, 1));
@@ -96,7 +193,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
         }
         else if (args.size() == 1) // WebSocketModule.close(this._socketId);
         {
-          weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 0));
+          weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 0), {}, weakState);
           if (auto sharedWs = weakWs.lock())
           {
             sharedWs->Close(IWebSocketResource::CloseCode::Normal, {});
@@ -104,137 +201,53 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
         }
         else
         {
-          auto errorObj = dynamic::object("id", -1)("message", "Incorrect number of parameters");
-          this->SendEvent("websocketFailed", std::move(errorObj));
+          auto state = weakState.lock();
+          if (state && state->Module) {
+            auto errorObj = dynamic::object("id", -1)("message", "Incorrect number of parameters");
+            SendEvent(state->Module->getInstance(), "websocketFailed", std::move(errorObj));
+          }
         }
-      }),
-    Method(
+      }
+    },
+    {
       "send",
-      [this](dynamic args) // const string& message, int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& message, int64_t id
       {
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 1));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 1), {}, weakState);
         if (auto sharedWs = weakWs.lock())
         {
           sharedWs->Send(jsArgAsString(args, 0));
         }
-      }),
-    Method(
+      }
+    },
+    {
       "sendBinary",
-      [this](dynamic args) // const string& base64String, int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // const string& base64String, int64_t id
       {
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 1));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 1), {}, weakState);
         if (auto sharedWs = weakWs.lock())
         {
           sharedWs->SendBinary(jsArgAsString(args, 0));
         }
-      }),
-    Method(
+      }
+    },
+    {
       "ping",
-      [this](dynamic args) // int64_t id
+      [weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) // int64_t id
       {
-        weak_ptr weakWs = this->GetOrCreateWebSocket(jsArgAsInt(args, 0));
+        weak_ptr weakWs = GetOrCreateWebSocket(jsArgAsInt(args, 0), {}, weakState);
         if (auto sharedWs = weakWs.lock())
         {
           sharedWs->Ping();
         }
-      })
+      }
+    }
   };
 } // getMethods
 // clang-format on
 
-#pragma region private members
-
-void WebSocketModule::SendEvent(string &&eventName, dynamic &&args) {
-  auto weakInstance = this->getInstance();
-  if (auto instance = weakInstance.lock()) {
-    instance->callJSFunction("RCTDeviceEventEmitter", "emit", dynamic::array(std::move(eventName), std::move(args)));
-  }
-}
-
-// clang-format off
-shared_ptr<IWebSocketResource> WebSocketModule::GetOrCreateWebSocket(int64_t id, string&& url)
-{
-  auto itr = m_webSockets.find(id);
-  if (itr == m_webSockets.end())
-  {
-    shared_ptr<IWebSocketResource> ws;
-    try
-    {
-      ws = m_resourceFactory(std::move(url));
-    }
-    catch (const winrt::hresult_error& e)
-    {
-      std::stringstream ss;
-      ss << "[" << std::hex << std::showbase << std::setw(8) << static_cast<uint32_t>(e.code()) << "] " <<
-        winrt::to_string(e.message());
-
-      SendEvent("webSocketFailed", dynamic::object("id", id)("message", std::move(ss.str())));
-
-      return nullptr;
-    }
-    catch (const std::exception& e)
-    {
-      SendEvent("webSocketFailed", dynamic::object("id", id)("message", e.what()));
-
-      return nullptr;
-    }
-    catch (...)
-    {
-      SendEvent("webSocketFailed", dynamic::object("id", id)("message", "Unidentified error creating IWebSocketResource"));
-
-      return nullptr;
-    }
-
-    auto weakInstance = this->getInstance();
-    ws->SetOnError([this, id, weakInstance](const IWebSocketResource::Error& err)
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto errorObj = dynamic::object("id", id)("message", err.Message);
-      this->SendEvent("websocketFailed", std::move(errorObj));
-    });
-    ws->SetOnConnect([this, id, weakInstance]()
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id);
-      this->SendEvent("websocketOpen", std::move(args));
-    });
-    ws->SetOnMessage([this, id, weakInstance](size_t length, const string& message, bool isBinary)
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id)("data", message)("type", isBinary ? "binary" : "text");
-      this->SendEvent("websocketMessage", std::move(args));
-    });
-    ws->SetOnClose([this, id, weakInstance](IWebSocketResource::CloseCode code, const string& reason)
-    {
-      auto strongInstance = weakInstance.lock();
-      if (!strongInstance)
-        return;
-
-      auto args = dynamic::object("id", id)("code", static_cast<uint16_t>(code))("reason", reason);
-      this->SendEvent("websocketClosed", std::move(args));
-    });
-
-    m_webSockets.emplace(id, ws);
-    return ws;
-  }
-
-  return itr->second;
-}
-// clang-format on
-
-#pragma endregion private members
-
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule() noexcept {
-  return make_unique<WebSocketModule>();
+  return std::make_unique<WebSocketModule>();
 }
 
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.h

@@ -18,6 +18,26 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
 
   WebSocketModule();
 
+  ~WebSocketModule() noexcept override;
+
+  struct SharedState {
+    /// <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>> ResourceMap{};
+
+    /// <summary>
+    /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
+    /// </summary>
+    std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> ResourceFactory;
+
+    /// <summary>
+    /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
+    /// </summary>
+    CxxModule *Module{nullptr};
+  };
+
 #pragma region CxxModule overrides
 
   /// <summary>
@@ -41,16 +61,6 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
   void SetResourceFactory(std::function<std::shared_ptr<IWebSocketResource>(const std::string &)> &&resourceFactory);
 
  private:
-  /// <summary>
-  /// Notifies an event to the current React Instance.
-  /// </summary>
-  void SendEvent(std::string &&eventName, folly::dynamic &&parameters);
-
-  /// <summary>
-  /// Creates or retrieves a raw <c>IWebSocketResource</c> pointer.
-  /// </summary>
-  std::shared_ptr<IWebSocketResource> GetOrCreateWebSocket(std::int64_t id, std::string &&url = {});
-
   /// <summary>
   /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
   /// As defined in WebSocket.js.
@@ -58,9 +68,9 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
   std::map<int64_t, std::shared_ptr<IWebSocketResource>> m_webSockets;
 
   /// <summary>
-  /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
+  /// Keeps members that can be accessed threads other than this module's owner accessible.
   /// </summary>
-  std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> m_resourceFactory;
+  std::shared_ptr<SharedState> m_sharedState;
 };
 
 } // namespace Microsoft::React

package/Shared/OInstance.cpp

@@ -193,7 +193,7 @@ class OJSIExecutorFactory : public JSExecutorFactory {
   }
 
   OJSIExecutorFactory(
-      std::shared_ptr<jsi::RuntimeHolderLazyInit> runtimeHolder,
+      std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder,
       NativeLoggingHook loggingHook,
       std::shared_ptr<TurboModuleRegistry> turboModuleRegistry,
       bool isProfilingEnabled,
@@ -205,7 +205,7 @@ class OJSIExecutorFactory : public JSExecutorFactory {
         isProfilingEnabled_{isProfilingEnabled} {}
 
  private:
-  std::shared_ptr<jsi::RuntimeHolderLazyInit> runtimeHolder_;
+  std::shared_ptr<Microsoft::JSI::RuntimeHolderLazyInit> runtimeHolder_;
   std::shared_ptr<TurboModuleRegistry> turboModuleRegistry_;
   std::shared_ptr<CallInvoker> jsCallInvoker_;
   NativeLoggingHook loggingHook_;
@@ -278,6 +278,20 @@ void InstanceImpl::SetInError() noexcept {
   m_isInError = true;
 }
 
+namespace {
+bool shouldStartHermesInspector(DevSettings &devSettings) {
+  bool isHermes =
+      ((devSettings.jsiEngineOverride == JSIEngineOverride::Hermes) ||
+       (devSettings.jsiEngineOverride == JSIEngineOverride::Default && devSettings.jsiRuntimeHolder &&
+        devSettings.jsiRuntimeHolder->getRuntimeType() == facebook::react::JSIEngineOverride::Hermes));
+
+  if (isHermes && devSettings.useDirectDebugger && !devSettings.useWebDebugger)
+    return true;
+  else
+    return false;
+}
+} // namespace
+
 InstanceImpl::InstanceImpl(
     std::shared_ptr<Instance> &&instance,
     std::string &&jsBundleBasePath,
@@ -305,8 +319,7 @@ InstanceImpl::InstanceImpl(
   facebook::react::tracing::initializeETW();
 #endif
 
-  if (m_devSettings->jsiEngineOverride == JSIEngineOverride::Hermes && m_devSettings->useDirectDebugger &&
-      !m_devSettings->useWebDebugger) {
+  if (shouldStartHermesInspector(*m_devSettings)) {
     m_devManager->StartInspector(m_devSettings->sourceBundleHost, m_devSettings->sourceBundlePort);
   }
 

package/Shared/V8JSIRuntimeHolder.cpp

@@ -31,6 +31,10 @@ class TaskRunnerAdapter : public v8runtime::JSITaskRunner {
   std::shared_ptr<facebook::react::MessageQueueThread> jsQueue_;
 };
 
+facebook::react::JSIEngineOverride V8JSIRuntimeHolder::getRuntimeType() noexcept {
+  return facebook::react::JSIEngineOverride::V8;
+}
+
 std::shared_ptr<facebook::jsi::Runtime> V8JSIRuntimeHolder::getRuntime() noexcept {
   std::call_once(once_flag_, [this]() { initRuntime(); });
 

package/Shared/V8JSIRuntimeHolder.h

@@ -13,9 +13,10 @@
 namespace facebook {
 namespace react {
 
-class V8JSIRuntimeHolder : public facebook::jsi::RuntimeHolderLazyInit {
+class V8JSIRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
  public:
   std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
+  facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
 
   V8JSIRuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,

package/Shared/WinRTWebSocketResource.cpp

@@ -90,29 +90,21 @@ namespace Microsoft::React {
 // private
 WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
-    Uri &&uri,
     vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource(
-          std::move(socket),
-          DataWriter{socket.OutputStream()},
-          std::move(uri),
-          std::move(certExceptions)) {}
+    : WinRTWebSocketResource(std::move(socket), DataWriter{socket.OutputStream()}, std::move(certExceptions)) {}
 
 WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
     IDataWriter &&writer,
-    Uri &&uri,
     vector<ChainValidationResult> &&certExceptions)
-    : m_uri{std::move(uri)}, m_socket{std::move(socket)}, m_writer{std::move(writer)} {
-  m_socket.MessageReceived({this, &WinRTWebSocketResource::OnMessageReceived});
-
+    : m_socket{std::move(socket)}, m_writer{std::move(writer)} {
   for (const auto &certException : certExceptions) {
     m_socket.Control().IgnorableServerCertificateErrors().Append(certException);
   }
 }
 
-WinRTWebSocketResource::WinRTWebSocketResource(const string &urlString, vector<ChainValidationResult> &&certExceptions)
-    : WinRTWebSocketResource(MessageWebSocket{}, Uri{winrt::to_hstring(urlString)}, std::move(certExceptions)) {}
+WinRTWebSocketResource::WinRTWebSocketResource(vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource(MessageWebSocket{}, std::move(certExceptions)) {}
 
 WinRTWebSocketResource::~WinRTWebSocketResource() noexcept /*override*/
 {
@@ -123,13 +115,14 @@ WinRTWebSocketResource::~WinRTWebSocketResource() noexcept /*override*/
 
 #pragma region Private members
 
-IAsyncAction WinRTWebSocketResource::PerformConnect() noexcept {
+IAsyncAction WinRTWebSocketResource::PerformConnect(Uri &&uri) noexcept {
   auto self = shared_from_this();
+  auto coUri = std::move(uri);
 
   co_await resume_background();
 
   try {
-    auto async = self->m_socket.ConnectAsync(self->m_uri);
+    auto async = self->m_socket.ConnectAsync(coUri);
 
     co_await lessthrow_await_adapter<IAsyncAction>{async};
 
@@ -293,36 +286,6 @@ fire_and_forget WinRTWebSocketResource::PerformClose() noexcept {
   m_closePerformed.Set();
 }
 
-void WinRTWebSocketResource::OnMessageReceived(
-    IWebSocket const &sender,
-    IMessageWebSocketMessageReceivedEventArgs const &args) {
-  try {
-    string response;
-    IDataReader reader = args.GetDataReader();
-    auto len = reader.UnconsumedBufferLength();
-    if (args.MessageType() == SocketMessageType::Utf8) {
-      reader.UnicodeEncoding(UnicodeEncoding::Utf8);
-      vector<uint8_t> data(len);
-      reader.ReadBytes(data);
-
-      response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
-    } else {
-      auto buffer = reader.ReadBuffer(len);
-      winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
-
-      response = winrt::to_string(std::wstring_view(data));
-    }
-
-    if (m_readHandler) {
-      m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
-    }
-  } catch (hresult_error const &e) {
-    if (m_errorHandler) {
-      m_errorHandler({HResultToString(e), ErrorType::Receive});
-    }
-  }
-}
-
 void WinRTWebSocketResource::Synchronize() noexcept {
   // Ensure sequence of other operations
   if (m_connectRequested) {
@@ -334,7 +297,36 @@ void WinRTWebSocketResource::Synchronize() noexcept {
 
 #pragma region IWebSocketResource
 
-void WinRTWebSocketResource::Connect(const Protocols &protocols, const Options &options) noexcept {
+void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
+  m_socket.MessageReceived(
+      [self = shared_from_this()](IWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
+        try {
+          string response;
+          IDataReader reader = args.GetDataReader();
+          auto len = reader.UnconsumedBufferLength();
+          if (args.MessageType() == SocketMessageType::Utf8) {
+            reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+            vector<uint8_t> data(len);
+            reader.ReadBytes(data);
+
+            response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
+          } else {
+            auto buffer = reader.ReadBuffer(len);
+            winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
+
+            response = winrt::to_string(std::wstring_view(data));
+          }
+
+          if (self->m_readHandler) {
+            self->m_readHandler(response.length(), response, args.MessageType() == SocketMessageType::Binary);
+          }
+        } catch (hresult_error const &e) {
+          if (self->m_errorHandler) {
+            self->m_errorHandler({HResultToString(e), ErrorType::Receive});
+          }
+        }
+      });
+
   m_readyState = ReadyState::Connecting;
 
   for (const auto &header : options) {
@@ -348,7 +340,24 @@ void WinRTWebSocketResource::Connect(const Protocols &protocols, const Options &
   }
 
   m_connectRequested = true;
-  PerformConnect();
+
+  Uri uri{nullptr};
+  try {
+    uri = Uri{winrt::to_hstring(url)};
+  } catch (hresult_error const &e) {
+    if (m_errorHandler) {
+      m_errorHandler({HResultToString(e), ErrorType::Connection});
+    }
+
+    // Abort - Mark connection as concluded.
+    SetEvent(m_connectPerformed.get());
+    m_connectPerformedPromise.set_value();
+    m_connectRequested = false;
+
+    return;
+  }
+
+  PerformConnect(std::move(uri));
 }
 
 void WinRTWebSocketResource::Ping() noexcept {