react-native-windows 0.69.0-preview.2 → 0.69.0-preview.5

package/Shared/Modules/BlobModule.h

@@ -0,0 +1,153 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Modules/IBlobPersistor.h>
+#include <Modules/IRequestBodyHandler.h>
+#include <Modules/IResponseHandler.h>
+#include <Modules/IWebSocketModuleContentHandler.h>
+
+// React Native
+#include <cxxreact/CxxModule.h>
+
+// Windows API
+#include <winrt/base.h>
+
+// Standard Library
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace Microsoft::React {
+
+class MemoryBlobPersistor final : public IBlobPersistor {
+  std::unordered_map<std::string, std::vector<uint8_t>> m_blobs;
+  std::mutex m_mutex;
+
+ public:
+#pragma region IBlobPersistor
+
+  winrt::array_view<uint8_t> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) override;
+
+  void RemoveMessage(std::string &&blobId) noexcept override;
+
+  void StoreMessage(std::vector<uint8_t> &&message, std::string &&blobId) noexcept override;
+
+  std::string StoreMessage(std::vector<uint8_t> &&message) noexcept override;
+
+#pragma endregion IBlobPersistor
+};
+
+class BlobWebSocketModuleContentHandler final : public IWebSocketModuleContentHandler {
+  std::unordered_set<int64_t> m_socketIds;
+  std::mutex m_mutex;
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobWebSocketModuleContentHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IWebSocketModuleContentHandler
+
+  void ProcessMessage(std::string &&message, folly::dynamic &params) override;
+
+  void ProcessMessage(std::vector<uint8_t> &&message, folly::dynamic &params) override;
+
+#pragma endregion IWebSocketModuleContentHandler
+
+  void Register(int64_t socketID) noexcept;
+
+  void Unregister(int64_t socketID) noexcept;
+};
+
+class BlobModuleRequestBodyHandler final : public IRequestBodyHandler {
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobModuleRequestBodyHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IRequestBodyHandler
+
+  bool Supports(folly::dynamic &data) override;
+
+  folly::dynamic ToRequestBody(folly::dynamic &data, std::string &contentType) override;
+
+#pragma endregion IRequestBodyHandler
+};
+
+class BlobModuleResponseHandler final : public IResponseHandler {
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobModuleResponseHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IResponseHandler
+
+  bool Supports(std::string &responseType) override;
+
+  folly::dynamic ToResponseData(std::vector<uint8_t> &&content) override;
+
+#pragma endregion IResponseHandler
+};
+
+class BlobModule : public facebook::xplat::module::CxxModule {
+  std::shared_ptr<MemoryBlobPersistor> m_blobPersistor;
+  std::shared_ptr<BlobWebSocketModuleContentHandler> m_contentHandler;
+  std::shared_ptr<BlobModuleRequestBodyHandler> m_requestBodyHandler;
+  std::shared_ptr<BlobModuleResponseHandler> m_responseHandler;
+
+  // Property bag high level reference.
+  winrt::Windows::Foundation::IInspectable m_inspectableProperties;
+
+ public:
+  enum class MethodId {
+    AddNetworkingHandler = 0,
+    AddWebSocketHandler = 1,
+    RemoveWebSocketHandler = 2,
+    SendOverSocket = 3,
+    CreateFromParts = 4,
+    Release = 5,
+    SIZE = 6
+  };
+
+  BlobModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
+
+  ~BlobModule() noexcept override;
+
+  struct SharedState {
+    /// <summary>
+    /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
+    /// </summary>
+    CxxModule *Module{nullptr};
+  };
+
+#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:
+  /// <summary>
+  /// Keeps members that can be accessed threads other than this module's owner accessible.
+  /// </summary>
+  std::shared_ptr<SharedState> m_sharedState;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/CxxModuleUtilities.cpp

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "CxxModuleUtilities.h"
+
+using facebook::react::Instance;
+using folly::dynamic;
+using std::string;
+using std::weak_ptr;
+
+namespace Microsoft::React::Modules {
+
+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)));
+  }
+}
+
+} // namespace Microsoft::React::Modules

package/Shared/Modules/CxxModuleUtilities.h

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Folly
+#include <folly/dynamic.h>
+
+// React Native
+#include <cxxreact/Instance.h>
+
+// Standard Library
+#include <memory>
+#include <string>
+
+namespace Microsoft::React::Modules {
+
+void SendEvent(
+    std::weak_ptr<facebook::react::Instance> weakReactInstance,
+    std::string &&eventName,
+    folly::dynamic &&args);
+
+} // namespace Microsoft::React::Modules

package/Shared/Modules/FileReaderModule.cpp

@@ -0,0 +1,156 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "FileReaderModule.h"
+
+#include <ReactPropertyBag.h>
+
+// Boost Library
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+// React Native
+#include <cxxreact/JsArgumentHelpers.h>
+
+// Windows API
+#include <winrt/Windows.Foundation.h>
+
+using namespace facebook::xplat;
+
+using folly::dynamic;
+using std::string;
+using std::weak_ptr;
+using winrt::Microsoft::ReactNative::IReactPropertyBag;
+using winrt::Microsoft::ReactNative::ReactNonAbiValue;
+using winrt::Microsoft::ReactNative::ReactPropertyBag;
+using winrt::Microsoft::ReactNative::ReactPropertyId;
+using winrt::Windows::Foundation::IInspectable;
+
+namespace {
+constexpr char moduleName[] = "FileReaderModule";
+} // namespace
+
+namespace Microsoft::React {
+
+#pragma region FileReaderModule
+
+FileReaderModule::FileReaderModule(weak_ptr<IBlobPersistor> weakBlobPersistor) noexcept
+    : m_weakBlobPersistor{weakBlobPersistor} {}
+
+FileReaderModule::~FileReaderModule() noexcept /*override*/
+{}
+
+#pragma region CxxModule
+
+string FileReaderModule::getName() {
+  return moduleName;
+}
+
+std::map<string, dynamic> FileReaderModule::getConstants() {
+  return {};
+}
+
+std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
+  return {
+      {///
+       /// <param name="args">
+       /// Array of arguments passed from the JavaScript layer.
+       /// [0]  - dynamic blob object { blobId, offset, size[, type] }
+       /// </param>
+       ///
+       "readAsDataURL",
+       [blobPersistor = m_weakBlobPersistor.lock()](dynamic args, Callback resolve, Callback reject) {
+         if (!blobPersistor) {
+           return reject({"Could not find Blob persistor"});
+         }
+
+         auto blob = jsArgAsObject(args, 0);
+
+         auto blobId = blob["blobId"].asString();
+         auto offset = blob["offset"].asInt();
+         auto size = blob["size"].asInt();
+
+         winrt::array_view<uint8_t> bytes;
+         try {
+           bytes = blobPersistor->ResolveMessage(std::move(blobId), offset, size);
+         } catch (const std::exception &e) {
+           return reject({e.what()});
+         }
+
+         auto result = string{"data:"};
+         auto typeItr = blob.find("type");
+         if (typeItr == blob.items().end()) {
+           result += "application/octet-stream";
+         } else {
+           result += (*typeItr).second.asString();
+         }
+         result += ";base64,";
+
+         // https://www.boost.org/doc/libs/1_76_0/libs/serialization/doc/dataflow.html
+         using namespace boost::archive::iterators;
+         typedef base64_from_binary<transform_width<const char *, 6, 8>> encode_base64;
+         std::ostringstream oss;
+         std::copy(encode_base64(bytes.cbegin()), encode_base64(bytes.cend()), ostream_iterator<char>(oss));
+         result += oss.str();
+
+         resolve({std::move(result)});
+       }},
+      {///
+       /// <param name="args">
+       /// Array of arguments passed from the JavaScript layer.
+       /// [0]  - dynamic blob object { blobId, offset, size }
+       /// [1]  - string encoding
+       /// </param>
+       ///
+       "readAsText",
+       [blobPersistor = m_weakBlobPersistor.lock()](dynamic args, Callback resolve, Callback reject) {
+         if (!blobPersistor) {
+           return reject({"Could not find Blob persistor"});
+         }
+
+         auto blob = jsArgAsObject(args, 0);
+         auto encoding = jsArgAsString(args, 1); // Default: "UTF-8"
+
+         auto blobId = blob["blobId"].asString();
+         auto offset = blob["offset"].asInt();
+         auto size = blob["size"].asInt();
+
+         winrt::array_view<uint8_t> bytes;
+         try {
+           bytes = blobPersistor->ResolveMessage(std::move(blobId), offset, size);
+         } catch (const std::exception &e) {
+           return reject({e.what()});
+         }
+
+         // #9982 - Handle non-UTF8 encodings
+         //         See https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/charset/Charset.html
+         auto result = string{bytes.cbegin(), bytes.cend()};
+
+         resolve({std::move(result)});
+       }}};
+}
+
+#pragma endregion CxxModule
+
+#pragma endregion FileReaderModule
+
+/*extern*/ const char *GetFileReaderModuleName() noexcept {
+  return moduleName;
+}
+
+/*extern*/ std::unique_ptr<module::CxxModule> CreateFileReaderModule(
+    IInspectable const &inspectableProperties) noexcept {
+  auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
+
+  if (auto prop = propBag.Get(propId)) {
+    auto weakBlobPersistor = prop.Value();
+
+    return std::make_unique<FileReaderModule>(weakBlobPersistor);
+  }
+
+  return nullptr;
+}
+
+} // namespace Microsoft::React

package/Shared/Modules/FileReaderModule.h

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IBlobPersistor.h"
+
+// React Native
+#include <cxxreact/CxxModule.h>
+
+// Folly
+#include <folly/dynamic.h>
+
+// Standard Library
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Microsoft::React {
+
+class FileReaderModule : public facebook::xplat::module::CxxModule {
+ public:
+  enum class MethodId { ReadAsDataURL = 0, ReadAsText = 1, SIZE = 2 };
+
+  FileReaderModule(std::weak_ptr<IBlobPersistor> weakBlobPersistor) noexcept;
+
+  ~FileReaderModule() 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:
+  std::weak_ptr<IBlobPersistor> m_weakBlobPersistor;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/HttpModule.cpp

@@ -5,6 +5,9 @@
 
 #include "HttpModule.h"
 
+#include <Modules/CxxModuleUtilities.h>
+#include <ReactPropertyBag.h>
+
 // React Native
 #include <cxxreact/Instance.h>
 #include <cxxreact/JsArgumentHelpers.h>
@@ -14,21 +17,34 @@ using folly::dynamic;
 using std::shared_ptr;
 using std::string;
 using std::weak_ptr;
+using winrt::Microsoft::ReactNative::IReactPropertyBag;
+using winrt::Microsoft::ReactNative::ReactNonAbiValue;
+using winrt::Microsoft::ReactNative::ReactPropertyBag;
+using winrt::Microsoft::ReactNative::ReactPropertyId;
+using winrt::Windows::Foundation::IInspectable;
 
 namespace {
 
+using Microsoft::React::Modules::SendEvent;
 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)));
-  }
-}
+// React event names
+constexpr char completedResponse[] = "didCompleteNetworkResponse";
+constexpr char receivedResponse[] = "didReceiveNetworkResponse";
+constexpr char receivedData[] = "didReceiveNetworkData";
+constexpr char receivedDataProgress[] = "didReceiveNetworkDataProgress";
 
-static shared_ptr<IHttpResource> CreateHttpResource(weak_ptr<Instance> weakReactInstance) {
-  auto resource = IHttpResource::Make();
+static void SetUpHttpResource(
+    shared_ptr<IHttpResource> resource,
+    weak_ptr<Instance> weakReactInstance,
+    IInspectable &inspectableProperties) {
+  resource->SetOnRequestSuccess([weakReactInstance](int64_t requestId) {
+    auto args = dynamic::array(requestId);
+
+    SendEvent(weakReactInstance, completedResponse, std::move(args));
+  });
 
   resource->SetOnResponse([weakReactInstance](int64_t requestId, IHttpResource::Response &&response) {
     dynamic headers = dynamic::object();
@@ -39,33 +55,39 @@ static shared_ptr<IHttpResource> CreateHttpResource(weak_ptr<Instance> weakReact
     // TODO: Test response content.
     dynamic args = dynamic::array(requestId, response.StatusCode, headers, response.Url);
 
-    SendEvent(weakReactInstance, "didReceiveNetworkResponse", std::move(args));
+    SendEvent(weakReactInstance, receivedResponse, 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));
+  resource->SetOnData([weakReactInstance](int64_t requestId, string &&responseData) {
+    SendEvent(weakReactInstance, receivedData, dynamic::array(requestId, std::move(responseData)));
 
     // TODO: Move into separate method IF not executed right after onData()
-    SendEvent(weakReactInstance, "didCompleteNetworkResponse", dynamic::array(requestId));
+    SendEvent(weakReactInstance, completedResponse, dynamic::array(requestId));
   });
 
+  // Explicitly declaring function type to avoid type inference ambiguity.
+  std::function<void(int64_t, dynamic &&)> onDataDynamic = [weakReactInstance](
+                                                               int64_t requestId, dynamic &&responseData) {
+    SendEvent(weakReactInstance, receivedData, dynamic::array(requestId, std::move(responseData)));
+  };
+  resource->SetOnData(std::move(onDataDynamic));
+
   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));
+    SendEvent(weakReactInstance, completedResponse, std::move(args));
   });
-
-  return resource;
 }
 
 } // namespace
 
 namespace Microsoft::React {
 
-HttpModule::HttpModule() noexcept : m_holder{std::make_shared<ModuleHolder>()} {
+HttpModule::HttpModule(IInspectable const &inspectableProperties) noexcept
+    : m_holder{std::make_shared<ModuleHolder>()},
+      m_inspectableProperties{inspectableProperties},
+      m_resource{IHttpResource::Make(inspectableProperties)} {
   m_holder->Module = this;
 }
 
@@ -86,10 +108,6 @@ std::map<string, dynamic> HttpModule::getConstants() {
 // 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
   {
     {
@@ -102,53 +120,32 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
         }
 
         auto resource = holder->Module->m_resource;
-        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        if (!holder->Module->m_isResourceSetup)
         {
-          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
+          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+          holder->Module->m_isResourceSetup = true;
+        }
 
-          IHttpResource::Headers headers;
-          for (auto& header : params["headers"].items()) {
-            headers.emplace(header.first.getString(), header.second.getString());
-          }
+        auto params = facebook::xplat::jsArgAsObject(args, 0);
+        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
+        resource->SendRequest(
+          params["method"].asString(),
+          params["url"].asString(),
+          params["requestId"].asInt(),
+          std::move(headers),
+          std::move(params["data"]),
+          params["responseType"].asString(),
+          params["incrementalUpdates"].asBool(),
+          static_cast<int64_t>(params["timeout"].asDouble()),
+          params["withCredentials"].asBool(),
+          [cxxCallback = std::move(cxxCallback)](int64_t requestId) {
+            cxxCallback({requestId});
+          }
+        );
       }
     },
     {
@@ -162,10 +159,13 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
         }
 
         auto resource = holder->Module->m_resource;
-        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        if (!holder->Module->m_isResourceSetup)
         {
-          resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
+          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+          holder->Module->m_isResourceSetup = true;
         }
+
+        resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
       }
     },
     {
@@ -179,10 +179,13 @@ std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods()
         }
 
         auto resource = holder->Module->m_resource;
-        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        if (!holder->Module->m_isResourceSetup)
         {
-          resource->ClearCookies();
+          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+          holder->Module->m_isResourceSetup = true;
         }
+
+        resource->ClearCookies();
       }
     }
   };

package/Shared/Modules/HttpModule.h

@@ -8,6 +8,9 @@
 // React Native
 #include <cxxreact/CxxModule.h>
 
+// Windows API
+#include <winrt/Windows.Foundation.h>
+
 namespace Microsoft::React {
 
 ///
@@ -18,7 +21,7 @@ class HttpModule : public facebook::xplat::module::CxxModule {
  public:
   enum MethodId { SendRequest = 0, AbortRequest = 1, ClearCookies = 2, LAST = ClearCookies };
 
-  HttpModule() noexcept;
+  HttpModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
 
   ~HttpModule() noexcept override;
 
@@ -49,5 +52,9 @@ class HttpModule : public facebook::xplat::module::CxxModule {
 
   std::shared_ptr<Networking::IHttpResource> m_resource;
   std::shared_ptr<ModuleHolder> m_holder;
+  bool m_isResourceSetup{false};
+
+  // Property bag high level reference.
+  winrt::Windows::Foundation::IInspectable m_inspectableProperties;
 };
 } // namespace Microsoft::React

package/Shared/Modules/IBlobPersistor.h

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Windows API
+#include <winrt/base.h>
+
+// Standard Library
+#include <string>
+#include <vector>
+
+namespace Microsoft::React {
+
+struct IBlobPersistor {
+  ///
+  /// <exception cref="std::invalid_argument">
+  /// When an entry for blobId cannot be found.
+  /// </exception>
+  ///
+  virtual winrt::array_view<uint8_t> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) = 0;
+
+  virtual void RemoveMessage(std::string &&blobId) noexcept = 0;
+
+  virtual void StoreMessage(std::vector<uint8_t> &&message, std::string &&blobId) noexcept = 0;
+
+  virtual std::string StoreMessage(std::vector<uint8_t> &&message) noexcept = 0;
+};
+
+} // namespace Microsoft::React