react-native-windows 0.69.0-preview.3 → 0.69.0-preview.4

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

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