react-native-windows 0.72.0 → 0.72.2

package/Shared/Modules/WebSocketModule.cpp

@@ -4,11 +4,16 @@
 #include "pch.h"
 
 #include <Modules/WebSocketModule.h>
+#include <Modules/WebSocketTurboModule.h>
 
+#include <CreateModules.h>
 #include <Modules/CxxModuleUtilities.h>
 #include <Modules/IWebSocketModuleContentHandler.h>
 #include <ReactPropertyBag.h>
 
+// fmt
+#include <fmt/format.h>
+
 // React Native
 #include <cxxreact/Instance.h>
 #include <cxxreact/JsArgumentHelpers.h>
@@ -19,6 +24,8 @@
 // Standard Libriary
 #include <iomanip>
 
+namespace msrn = winrt::Microsoft::ReactNative;
+
 using namespace facebook::xplat;
 
 using facebook::react::Instance;
@@ -26,6 +33,7 @@ using folly::dynamic;
 
 using std::shared_ptr;
 using std::string;
+using std::vector;
 using std::weak_ptr;
 
 using winrt::Microsoft::ReactNative::IReactPropertyBag;
@@ -42,7 +50,10 @@ using Microsoft::React::WebSocketModule;
 using Microsoft::React::Modules::SendEvent;
 using Microsoft::React::Networking::IWebSocketResource;
 
-constexpr char moduleName[] = "WebSocketModule";
+constexpr char s_moduleName[] = "WebSocketModule";
+constexpr wchar_t s_moduleNameW[] = L"WebSocketModule";
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::WebSocketTurboModule>();
 
 static shared_ptr<IWebSocketResource>
 GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedState> weakState) {
@@ -105,7 +116,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
           if (!strongInstance)
             return;
 
-          dynamic args = dynamic::object("id", id)("type", isBinary ? "binary" : "text");
+          auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
           shared_ptr<Microsoft::React::IWebSocketModuleContentHandler> contentHandler;
           auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<Microsoft::React::IWebSocketModuleContentHandler>>>{
               L"BlobModule.ContentHandler"};
@@ -117,7 +128,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
               auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
               winrt::com_array<uint8_t> arr;
               CryptographicBuffer::CopyToByteArray(buffer, arr);
-              auto data = std::vector<uint8_t>(arr.begin(), arr.end());
+              auto data = vector<uint8_t>(arr.begin(), arr.end());
 
               contentHandler->ProcessMessage(std::move(data), args);
             } else {
@@ -127,7 +138,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
             args["data"] = message;
           }
 
-          SendEvent(weakInstance, "websocketMessage", std::move(args));
+          SendEvent(weakInstance, "websocketMessage", Microsoft::React::Modules::ToDynamic(std::move(args)));
         });
     ws->SetOnClose([id, weakInstance](IWebSocketResource::CloseCode code, const string &reason) {
       auto strongInstance = weakInstance.lock();
@@ -179,7 +190,7 @@ void WebSocketModule::SetResourceFactory(
 }
 
 string WebSocketModule::getName() {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> WebSocketModule::getConstants() {
@@ -187,7 +198,7 @@ std::map<string, dynamic> WebSocketModule::getConstants() {
 }
 
 // clang-format off
-std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMethods()
+vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMethods()
 {
   return
   {
@@ -312,8 +323,172 @@ void WebSocketModuleProxy::SendBinary(std::string &&base64String, int64_t id) no
 
 #pragma endregion WebSocketModuleProxy
 
+#pragma region WebSocketTurboModule
+
+shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id, string &&url) noexcept {
+  shared_ptr<IWebSocketResource> rc;
+  try {
+    rc = IWebSocketResource::Make();
+  } catch (const winrt::hresult_error &e) {
+    auto error = fmt::format("[0x{:0>8x}] {}", static_cast<uint32_t>(e.code()), winrt::to_string(e.message()));
+    SendEvent(m_context, L"webSocketFailed", {{"id", id}, {"message", std::move(error)}});
+
+    return nullptr;
+  } catch (const std::exception &e) {
+    SendEvent(m_context, L"webSocketFailed", {{"id", id}, {"message", e.what()}});
+
+    return nullptr;
+  } catch (...) {
+    SendEvent(
+        m_context, L"webSocketFailed", {{"id", id}, {"message", "Unidentified error creating IWebSocketResource"}});
+
+    return nullptr;
+  }
+
+  // Set up resource
+  rc->SetOnConnect([id, context = m_context]() {
+    SendEvent(context, L"websocketOpen", msrn::JSValueObject{{"id", id}});
+  });
+
+  rc->SetOnMessage([id, context = m_context](size_t length, const string &message, bool isBinary) {
+    auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
+    shared_ptr<IWebSocketModuleContentHandler> contentHandler;
+    auto propId =
+        ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
+    auto propBag = context.Properties();
+    if (auto prop = propBag.Get(propId))
+      contentHandler = prop.Value().lock();
+
+    if (contentHandler) {
+      if (isBinary) {
+        auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
+        winrt::com_array<uint8_t> arr;
+        CryptographicBuffer::CopyToByteArray(buffer, arr);
+        auto data = vector<uint8_t>(arr.begin(), arr.end());
+
+        contentHandler->ProcessMessage(std::move(data), args);
+      } else {
+        contentHandler->ProcessMessage(string{message}, args);
+      }
+    } else {
+      args["data"] = message;
+    }
+
+    SendEvent(context, L"websocketMessage", std::move(args));
+  });
+
+  rc->SetOnClose([id, context = m_context](IWebSocketResource::CloseCode code, const string &reason) {
+    auto args = msrn::JSValueObject{{"id", id}, {"code", static_cast<uint16_t>(code)}, {"reason", reason}};
+
+    SendEvent(context, L"websocketClosed", std::move(args));
+  });
+
+  rc->SetOnError([id, context = m_context](const IWebSocketResource::Error &err) {
+    auto errorObj = msrn::JSValueObject{{"id", id}, {"message", err.Message}};
+
+    SendEvent(context, L"websocketFailed", std::move(errorObj));
+  });
+
+  m_resourceMap.emplace(static_cast<double>(id), rc);
+
+  return rc;
+}
+
+void WebSocketTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  m_context = reactContext.Handle();
+}
+
+void WebSocketTurboModule::Connect(
+    string &&url,
+    std::optional<vector<string>> protocols,
+    ReactNativeSpecs::WebSocketModuleSpec_connect_options &&options,
+    double socketID) noexcept {
+  IWebSocketResource::Protocols rcProtocols;
+  for (const auto &protocol : protocols.value_or(vector<string>{})) {
+    rcProtocols.push_back(protocol);
+  }
+
+  IWebSocketResource::Options rcOptions;
+  auto &optHeaders = options.headers;
+  if (optHeaders.has_value()) {
+    auto &headersVal = optHeaders.value();
+    for (const auto &headerVal : headersVal.AsArray()) {
+      // Each header JSValueObject should only contain one key-value pair
+      const auto &entry = *headerVal.AsObject().cbegin();
+      rcOptions.emplace(winrt::to_hstring(entry.first), entry.second.AsString());
+    }
+  }
+
+  weak_ptr<IWebSocketResource> weakRc;
+  auto rcItr = m_resourceMap.find(socketID);
+  if (rcItr != m_resourceMap.cend()) {
+    weakRc = (*rcItr).second;
+  } else {
+    weakRc = CreateResource(static_cast<int64_t>(socketID), string{url});
+  }
+
+  if (auto rc = weakRc.lock()) {
+    rc->Connect(std::move(url), rcProtocols, rcOptions);
+  }
+}
+
+void WebSocketTurboModule::Close(double code, string &&reason, double socketID) noexcept {
+  auto rcItr = m_resourceMap.find(socketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->Close(static_cast<IWebSocketResource::CloseCode>(code), std::move(reason));
+  }
+}
+
+void WebSocketTurboModule::Send(string &&message, double forSocketID) noexcept {
+  auto rcItr = m_resourceMap.find(forSocketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->Send(std::move(message));
+  }
+}
+
+void WebSocketTurboModule::SendBinary(string &&base64String, double forSocketID) noexcept {
+  auto rcItr = m_resourceMap.find(forSocketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->SendBinary(std::move(base64String));
+  }
+}
+
+void WebSocketTurboModule::Ping(double socketID) noexcept {
+  auto rcItr = m_resourceMap.find(socketID);
+  if (rcItr == m_resourceMap.cend()) {
+    return; // TODO: Send error instead?
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->Ping();
+  }
+}
+
+// See react-native/ReactAndroid/src/main/java/com/facebook/react/modules/websocket/WebSocketModule.java
+void WebSocketTurboModule::AddListener(string && /*eventName*/) noexcept {}
+
+void WebSocketTurboModule::RemoveListeners(double /*count*/) noexcept {}
+
+#pragma endregion WebSocketTurboModule
+
 /*extern*/ const char *GetWebSocketModuleName() noexcept {
-  return moduleName;
+  return s_moduleName;
 }
 
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule(
@@ -324,4 +499,12 @@ void WebSocketModuleProxy::SendBinary(std::string &&base64String, int64_t id) no
   return nullptr;
 }
 
+/*extern*/ const wchar_t *GetWebSocketTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetWebSocketModuleProvider() noexcept {
+  return s_moduleProvider;
+}
+
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketTurboModule.h

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <NativeWebSocketModuleSpec.g.h>
+#include <Modules/IWebSocketModuleProxy.h>
+#include <NativeModules.h>
+#include <Networking/IWebSocketResource.h>
+
+namespace Microsoft::React {
+
+REACT_MODULE(WebSocketTurboModule, L"WebSocketModule")
+struct WebSocketTurboModule {
+  using ModuleSpec = ReactNativeSpecs::WebSocketModuleSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(Connect, L"connect")
+  void Connect(
+      std::string &&url,
+      std::optional<std::vector<std::string>> protocols,
+      ReactNativeSpecs::WebSocketModuleSpec_connect_options &&options,
+      double socketID) noexcept;
+
+  REACT_METHOD(Close, L"close")
+  void Close(double code, std::string &&reason, double socketID) noexcept;
+
+  REACT_METHOD(Send, L"send")
+  void Send(std::string &&message, double forSocketID) noexcept;
+
+  REACT_METHOD(SendBinary, L"sendBinary")
+  void SendBinary(std::string &&base64String, double forSocketID) noexcept;
+
+  REACT_METHOD(Ping, L"ping")
+  void Ping(double socketID) noexcept;
+
+  REACT_METHOD(AddListener, L"addListener")
+  void AddListener(std::string &&eventName) noexcept;
+
+  REACT_METHOD(RemoveListeners, L"removeListeners")
+  void RemoveListeners(double count) noexcept;
+
+ private:
+  std::shared_ptr<Networking::IWebSocketResource> CreateResource(int64_t id, std::string &&url) noexcept;
+
+  winrt::Microsoft::ReactNative::ReactContext m_context;
+  std::unordered_map<double, std::shared_ptr<Networking::IWebSocketResource>> m_resourceMap;
+};
+
+} // namespace Microsoft::React

package/Shared/Networking/DefaultBlobResource.cpp

@@ -0,0 +1,323 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "DefaultBlobResource.h"
+
+#include <Modules/IHttpModuleProxy.h>
+#include <Modules/IWebSocketModuleProxy.h>
+
+// Boost Libraries
+#include <boost/uuid/uuid_io.hpp>
+
+// Windows API
+#include <winrt/Windows.Security.Cryptography.h>
+
+using std::scoped_lock;
+using std::shared_ptr;
+using std::string;
+using std::vector;
+using std::weak_ptr;
+using winrt::array_view;
+using winrt::Windows::Security::Cryptography::CryptographicBuffer;
+
+namespace msrn = winrt::Microsoft::ReactNative;
+
+namespace {
+
+constexpr Microsoft::React::Networking::IBlobResource::BlobFieldNames
+    blobKeys{"blob", "blobId", "offset", "size", "type", "data"};
+
+} // namespace
+
+namespace Microsoft::React::Networking {
+
+#pragma region DefaultBlobResource
+
+DefaultBlobResource::DefaultBlobResource(
+    shared_ptr<MemoryBlobPersistor> blobPersistor,
+    shared_ptr<BlobWebSocketModuleContentHandler> contentHandler,
+    shared_ptr<BlobModuleRequestBodyHandler> requestBodyHandler,
+    shared_ptr<BlobModuleResponseHandler> responseHandler,
+    msrn::ReactPropertyBag propertyBag)
+    : m_blobPersistor{blobPersistor},
+      m_contentHandler{contentHandler},
+      m_requestBodyHandler{requestBodyHandler},
+      m_responseHandler{responseHandler},
+      m_propertyBag{propertyBag} {}
+
+#pragma region IBlobResource
+
+/*static*/ const IBlobResource::BlobFieldNames &IBlobResource::FieldNames() noexcept {
+  return blobKeys;
+}
+
+/*static*/ shared_ptr<IBlobResource> IBlobResource::Make(
+    winrt::Windows::Foundation::IInspectable const &inspectableProperties) {
+  using namespace msrn;
+
+  auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
+
+  auto blobPersistor = std::make_shared<MemoryBlobPersistor>();
+  auto contentHandler = std::make_shared<BlobWebSocketModuleContentHandler>(blobPersistor);
+  auto requestBodyHanlder = std::make_shared<BlobModuleRequestBodyHandler>(blobPersistor);
+  auto responseHandler = std::make_shared<BlobModuleResponseHandler>(blobPersistor);
+
+  auto contentHandlerPropId =
+      ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
+  propBag.Set(contentHandlerPropId, weak_ptr<IWebSocketModuleContentHandler>{contentHandler});
+
+  auto blobPersistorPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  ;
+  propBag.Set(blobPersistorPropId, weak_ptr<IBlobPersistor>{blobPersistor});
+
+  auto result = std::make_shared<DefaultBlobResource>(
+      blobPersistor, contentHandler, requestBodyHanlder, responseHandler, propBag);
+
+  return result;
+}
+
+void DefaultBlobResource::SendOverSocket(string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept
+/*override*/ {
+  auto propId =
+      msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
+  shared_ptr<IWebSocketModuleProxy> wsProxy;
+  if (auto prop = m_propertyBag.Get(propId)) {
+    wsProxy = prop.Value().lock();
+  }
+  if (!wsProxy) {
+    return;
+  }
+
+  array_view<uint8_t const> data;
+  try {
+    data = m_blobPersistor->ResolveMessage(std::move(blobId), offset, size);
+  } catch (const std::exception &e) {
+    return m_callbacks.OnError(e.what());
+  }
+
+  auto buffer = CryptographicBuffer::CreateFromByteArray(data);
+  auto base64Hstring = CryptographicBuffer::EncodeToBase64String(std::move(buffer));
+  auto base64String = winrt::to_string(base64Hstring);
+
+  wsProxy->SendBinary(std::move(base64String), socketId);
+}
+
+void DefaultBlobResource::CreateFromParts(msrn::JSValueArray &&parts, string &&blobId) noexcept /*override*/ {
+  vector<uint8_t> buffer{};
+
+  for (const auto &partItem : parts) {
+    auto &part = partItem.AsObject();
+    auto type = part.at(blobKeys.Type).AsString();
+    if (blobKeys.Blob == type) {
+      auto &blob = part.at(blobKeys.Data).AsObject();
+      array_view<uint8_t const> bufferPart;
+      try {
+        bufferPart = m_blobPersistor->ResolveMessage(
+            blob.at(blobKeys.BlobId).AsString(), blob.at(blobKeys.Offset).AsInt64(), blob.at(blobKeys.Size).AsInt64());
+      } catch (const std::exception &e) {
+        return m_callbacks.OnError(e.what());
+      }
+
+      buffer.reserve(buffer.size() + bufferPart.size());
+      buffer.insert(buffer.end(), bufferPart.begin(), bufferPart.end());
+    } else if ("string" == type) {
+      auto data = part.at(blobKeys.Data).AsString();
+
+      buffer.reserve(buffer.size() + data.size());
+      buffer.insert(buffer.end(), data.begin(), data.end());
+    } else {
+      return m_callbacks.OnError("Invalid type for blob: " + type);
+    }
+  }
+
+  m_blobPersistor->StoreMessage(std::move(buffer), std::move(blobId));
+}
+
+void DefaultBlobResource::Release(string &&blobId) noexcept /*override*/ {
+  m_blobPersistor->RemoveMessage(std::move(blobId));
+}
+
+void DefaultBlobResource::AddNetworkingHandler() noexcept /*override*/ {
+  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
+
+  if (auto prop = m_propertyBag.Get(propId)) {
+    if (auto httpHandler = prop.Value().lock()) {
+      httpHandler->AddRequestBodyHandler(m_requestBodyHandler);
+      httpHandler->AddResponseHandler(m_responseHandler);
+    }
+  }
+  // TODO: else emit error?
+}
+
+void DefaultBlobResource::AddWebSocketHandler(int64_t id) noexcept /*override*/ {
+  m_contentHandler->Register(id);
+}
+
+void DefaultBlobResource::RemoveWebSocketHandler(int64_t id) noexcept /*override*/ {
+  m_contentHandler->Unregister(id);
+}
+
+IBlobResource::BlobCallbacks &DefaultBlobResource::Callbacks() noexcept /*override*/ {
+  return m_callbacks;
+}
+
+#pragma endregion IBlobResource
+
+#pragma endregion DefaultBlobResource
+
+#pragma region MemoryBlobPersistor
+
+#pragma region IBlobPersistor
+
+array_view<uint8_t const> MemoryBlobPersistor::ResolveMessage(string &&blobId, int64_t offset, int64_t size) {
+  if (size < 1)
+    return {};
+
+  scoped_lock lock{m_mutex};
+
+  auto dataItr = m_blobs.find(std::move(blobId));
+  // Not found.
+  if (dataItr == m_blobs.cend())
+    throw std::invalid_argument("Blob object not found");
+
+  auto &bytes = (*dataItr).second;
+  auto endBound = static_cast<size_t>(offset + size);
+  // Out of bounds.
+  if (endBound > bytes.size() || offset >= static_cast<int64_t>(bytes.size()) || offset < 0)
+    throw std::out_of_range("Offset or size out of range");
+
+  return array_view<uint8_t const>(bytes.data() + offset, bytes.data() + endBound);
+}
+
+void MemoryBlobPersistor::RemoveMessage(string &&blobId) noexcept {
+  scoped_lock lock{m_mutex};
+
+  m_blobs.erase(std::move(blobId));
+}
+
+void MemoryBlobPersistor::StoreMessage(vector<uint8_t> &&message, string &&blobId) noexcept {
+  scoped_lock lock{m_mutex};
+
+  m_blobs.insert_or_assign(std::move(blobId), std::move(message));
+}
+
+string MemoryBlobPersistor::StoreMessage(vector<uint8_t> &&message) noexcept {
+  auto blobId = boost::uuids::to_string(m_guidGenerator());
+
+  scoped_lock lock{m_mutex};
+  m_blobs.insert_or_assign(blobId, std::move(message));
+
+  return blobId;
+}
+
+#pragma endregion IBlobPersistor
+
+#pragma endregion MemoryBlobPersistor
+
+#pragma region BlobWebSocketModuleContentHandler
+
+BlobWebSocketModuleContentHandler::BlobWebSocketModuleContentHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
+    : m_blobPersistor{blobPersistor} {}
+
+#pragma region IWebSocketModuleContentHandler
+
+void BlobWebSocketModuleContentHandler::ProcessMessage(
+    string &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  params[blobKeys.Data] = std::move(message);
+}
+
+void BlobWebSocketModuleContentHandler::ProcessMessage(
+    vector<uint8_t> &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  auto blob = msrn::JSValueObject{
+      {blobKeys.Offset, 0},
+      {blobKeys.Size, message.size()},
+      {blobKeys.BlobId, m_blobPersistor->StoreMessage(std::move(message))}};
+
+  params[blobKeys.Data] = std::move(blob);
+  params[blobKeys.Type] = blobKeys.Blob;
+}
+
+#pragma endregion IWebSocketModuleContentHandler
+
+void BlobWebSocketModuleContentHandler::Register(int64_t socketID) noexcept {
+  scoped_lock lock{m_mutex};
+  m_socketIds.insert(socketID);
+}
+
+void BlobWebSocketModuleContentHandler::Unregister(int64_t socketID) noexcept {
+  scoped_lock lock{m_mutex};
+
+  auto itr = m_socketIds.find(socketID);
+  if (itr != m_socketIds.end())
+    m_socketIds.erase(itr);
+}
+
+#pragma endregion BlobWebSocketModuleContentHandler
+
+#pragma region BlobModuleRequestBodyHandler
+
+BlobModuleRequestBodyHandler::BlobModuleRequestBodyHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
+    : m_blobPersistor{blobPersistor} {}
+
+#pragma region IRequestBodyHandler
+
+bool BlobModuleRequestBodyHandler::Supports(msrn::JSValueObject &data) /*override*/ {
+  auto itr = data.find(blobKeys.Blob);
+
+  return itr != data.cend() && !(*itr).second.AsString().empty();
+}
+
+msrn::JSValueObject BlobModuleRequestBodyHandler::ToRequestBody(
+    msrn::JSValueObject &data,
+    string &contentType) /*override*/ {
+  auto type = contentType;
+  auto itr = data.find(blobKeys.Type);
+  if (itr != data.cend() && !(*itr).second.AsString().empty()) {
+    type = (*itr).second.AsString();
+  }
+  if (type.empty()) {
+    type = "application/octet-stream";
+  }
+
+  auto &blob = data[blobKeys.Blob].AsObject();
+  auto blobId = blob[blobKeys.BlobId].AsString();
+  auto bytes = m_blobPersistor->ResolveMessage(
+      std::move(blobId), blob[blobKeys.Offset].AsInt64(), blob[blobKeys.Size].AsInt64());
+
+  return {
+      {blobKeys.Type, type},
+      {blobKeys.Size, bytes.size()},
+      {"bytes", msrn::JSValueArray(bytes.cbegin(), bytes.cend())}};
+}
+
+#pragma endregion IRequestBodyHandler
+
+#pragma endregion BlobModuleRequestBodyHandler
+
+#pragma region BlobModuleResponseHandler
+
+BlobModuleResponseHandler::BlobModuleResponseHandler(shared_ptr<IBlobPersistor> blobPersistor) noexcept
+    : m_blobPersistor{blobPersistor} {}
+
+#pragma region IResponseHandler
+
+bool BlobModuleResponseHandler::Supports(string &responseType) /*override*/ {
+  return blobKeys.Blob == responseType;
+}
+
+msrn::JSValueObject BlobModuleResponseHandler::ToResponseData(vector<uint8_t> &&content) /*override*/ {
+  return {
+      {blobKeys.Offset, 0},
+      {blobKeys.Size, content.size()},
+      {blobKeys.BlobId, m_blobPersistor->StoreMessage(std::move(content))}};
+}
+
+#pragma endregion IResponseHandler
+
+#pragma endregion BlobModuleResponseHandler
+
+} // namespace Microsoft::React::Networking