react-native-windows 0.67.7 → 0.67.10

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

@@ -0,0 +1,201 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "HttpModule.h"
+
+#include <Modules/CxxModuleUtilities.h>
+#include <ReactPropertyBag.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;
+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";
+
+// React event names
+constexpr char completedResponse[] = "didCompleteNetworkResponse";
+constexpr char receivedResponse[] = "didReceiveNetworkResponse";
+constexpr char receivedData[] = "didReceiveNetworkData";
+constexpr char receivedDataProgress[] = "didReceiveNetworkDataProgress";
+
+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();
+    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, receivedResponse, 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, 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, completedResponse, std::move(args));
+  });
+}
+
+} // namespace
+
+namespace Microsoft::React {
+
+HttpModule::HttpModule(IInspectable const &inspectableProperties) noexcept
+    : m_holder{std::make_shared<ModuleHolder>()},
+      m_inspectableProperties{inspectableProperties},
+      m_resource{IHttpResource::Make(inspectableProperties)} {
+  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() {
+
+  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 (!holder->Module->m_isResourceSetup)
+        {
+          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+          holder->Module->m_isResourceSetup = true;
+        }
+
+        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(),
+          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});
+          }
+        );
+      }
+    },
+    {
+      "abortRequest",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder)
+        {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (!holder->Module->m_isResourceSetup)
+        {
+          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+          holder->Module->m_isResourceSetup = true;
+        }
+
+        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 (!holder->Module->m_isResourceSetup)
+        {
+          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+          holder->Module->m_isResourceSetup = true;
+        }
+
+        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,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Networking/IHttpResource.h>
+
+// React Native
+#include <cxxreact/CxxModule.h>
+
+// Windows API
+#include <winrt/Windows.Foundation.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(winrt::Windows::Foundation::IInspectable const &inspectableProperties) 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;
+  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

package/Shared/Modules/IHttpModuleProxy.h

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IRequestBodyHandler.h"
+#include "IResponseHandler.h"
+#include "IUriHandler.h"
+
+// Standard Library
+#include <functional>
+
+namespace Microsoft::React {
+
+/// <summary>
+/// Provides partial access to HttpModule methods directly to other native modules
+/// without switching to the JavaScript queue thread.
+/// </summary>
+struct IHttpModuleProxy {
+  virtual ~IHttpModuleProxy() noexcept {}
+
+  // TODO: Implement custom URI handlers.
+  virtual void AddUriHandler(std::shared_ptr<IUriHandler> uriHandler) noexcept = 0;
+
+  virtual void AddRequestBodyHandler(std::shared_ptr<IRequestBodyHandler> requestBodyHandler) noexcept = 0;
+
+  virtual void AddResponseHandler(std::shared_ptr<IResponseHandler> responseHandler) noexcept = 0;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/IRequestBodyHandler.h

@@ -0,0 +1,52 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Folly
+#include <folly/dynamic.h>
+
+// Standard Library
+#include <string>
+
+namespace Microsoft::React {
+
+/// <summary>
+/// Allows adding custom handling to build the {@link RequestBody} from the JS body payload.
+/// </summary>
+struct IRequestBodyHandler {
+  /// <summary>
+  /// Returns if the handler should be used for a JS body payload.
+  /// </summary>
+  /// <param name="data">
+  /// folly object potentially containing a blob reference.
+  /// "blob"  - folly object holding blob metadata. Optional.
+  /// </param>
+  /// <returns>
+  /// true  - <paramref name="data" /> contains a blob reference.
+  /// false - <paramref name="data" /> does not contain a blob reference.
+  /// </returns>
+  virtual bool Supports(folly::dynamic &data) = 0;
+
+  /// <summary>
+  /// Returns the {@link RequestBody} for the JS body payload.
+  /// </summary>
+  /// <param name="data">
+  /// Incoming folly object containing the blob metadada.
+  /// Structure:
+  /// "blob"  - folly object info
+  ///   "blobId"  - Blob unique identifier
+  ///   "offset"  - Start index to read the blob
+  ///   "size"    - Amount of bytes to read from the blob
+  /// </param>
+  /// <returns>
+  /// folly::dynamic object with the following entries:
+  /// "type"  - Request content type
+  /// "size"  - Amount of bytes
+  /// "bytes" - Raw body content
+  ///           NOTE: This is an arbitrary key. Pending non-folly structured object to model request body.
+  /// </returns>
+  virtual folly::dynamic ToRequestBody(folly::dynamic &data, std::string &contentType) = 0;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/IResponseHandler.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// Folly
+#include <folly/dynamic.h>
+
+// Standard Library
+#include <string>
+#include <vector>
+
+namespace Microsoft::React {
+
+/// <summary>
+/// Allows adding custom handling to build the JS body payload from the {@link ResponseBody}.
+/// </summary>
+struct IResponseHandler {
+  /// <summary>
+  /// Returns if the handler should be used for a response type.
+  /// </summary>
+  virtual bool Supports(std::string &responseType) = 0;
+
+  /// <summary>
+  /// Returns the JS body payload for the {@link ResponseBody}.
+  /// </summary>
+  virtual folly::dynamic ToResponseData(std::vector<uint8_t> &&content) = 0;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/IUriHandler.h

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Folly
+#include <folly/dynamic.h>
+
+// Standard Library
+#include <string>
+
+namespace Microsoft::React {
+
+/// <summary>
+/// Allows to implement a custom fetching process for specific URIs. It is the handler's job to
+/// fetch the URI and return the JS body payload.
+/// </summary>
+struct IUriHandler {
+  /// <summary>
+  /// Returns whether the handler should be used for a given URI.
+  /// </summary>
+  virtual bool Supports(std::string &uri, std::string &responseType) = 0;
+
+  /// <summary>
+  /// Fetch the URI and return the JS body payload.
+  /// </summary>
+  /// <returns>
+  /// Blob representation in a dynamic object with the folliwing structure:
+  /// "blobId"      - Blob unique identifier
+  /// "offset"      - Blob segment starting offset
+  /// "size"        - Number of bytes fetched from blob
+  /// "name"        - File name obtained from the URI
+  /// "lastModified - Last write to local file in milliseconds
+  virtual folly::dynamic Fetch(std::string &uri) = 0;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/IWebSocketModuleContentHandler.h

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// React Native
+#include <folly/dynamic.h>
+
+// Standard Library
+#include <string>
+#include <vector>
+
+namespace Microsoft::React {
+
+/// <summary>
+/// See https://github.com/facebook/react-native/blob/v0.63.2/React/CoreModules/RCTWebSocketModule.h#L12
+/// </summary>
+struct IWebSocketModuleContentHandler {
+  virtual ~IWebSocketModuleContentHandler() noexcept {}
+
+  virtual void ProcessMessage(std::string &&message, folly::dynamic &params) = 0;
+
+  virtual void ProcessMessage(std::vector<uint8_t> &&message, folly::dynamic &params) = 0;
+};
+
+} // namespace Microsoft::React