react-native-windows 0.66.18 → 0.66.21

package/Shared/Modules/IWebSocketModuleProxy.h

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Standard Library
+#include <memory>
+#include <string>
+
+namespace Microsoft::React {
+
+/// <summary>
+/// Provides partial access to WebSocketModule methods directly to other native modules
+/// without switching to the JavaScript queue thread.
+/// </summary>
+struct IWebSocketModuleProxy {
+  virtual ~IWebSocketModuleProxy() noexcept {}
+
+  virtual void SendBinary(std::string &&base64String, int64_t id) noexcept = 0;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/NetworkingModule.cpp

@@ -261,7 +261,7 @@ void NetworkingModule::NetworkingHelper::SendRequest(
   int64_t requestId = ++s_lastRequestId;
 
   // Enforce supported args
-  assert(responseType == "text" || responseType == "base64");
+  assert(responseType == "text" || responseType == "base64" || responseType == "blob");
 
   // Callback with the requestId
   cb({requestId});

package/Shared/Modules/WebSocketModule.cpp

@@ -5,10 +5,16 @@
 
 #include <Modules/WebSocketModule.h>
 
-#include <Utils.h>
+#include <Modules/CxxModuleUtilities.h>
+#include <Modules/IWebSocketModuleContentHandler.h>
+#include <ReactPropertyBag.h>
+
+// React Native
 #include <cxxreact/Instance.h>
 #include <cxxreact/JsArgumentHelpers.h>
-#include "Unicode.h"
+
+// Windows API
+#include <winrt/Windows.Security.Cryptography.h>
 
 // Standard Libriary
 #include <iomanip>
@@ -18,25 +24,26 @@ using namespace facebook::xplat;
 using facebook::react::Instance;
 using folly::dynamic;
 
-using Microsoft::Common::Unicode::Utf16ToUtf8;
-using Microsoft::Common::Unicode::Utf8ToUtf16;
-
 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;
+using winrt::Windows::Security::Cryptography::CryptographicBuffer;
+
 namespace {
-using Microsoft::React::IWebSocketResource;
+using Microsoft::React::IWebSocketModuleProxy;
 using Microsoft::React::WebSocketModule;
+using Microsoft::React::Modules::SendEvent;
+using Microsoft::React::Networking::IWebSocketResource;
 
 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();
@@ -91,14 +98,37 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
       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;
+    ws->SetOnMessage(
+        [id, weakInstance, propBag = ReactPropertyBag{state->InspectableProps.try_as<IReactPropertyBag>()}](
+            size_t length, const string &message, bool isBinary) {
+          auto strongInstance = weakInstance.lock();
+          if (!strongInstance)
+            return;
+
+          dynamic args = dynamic::object("id", id)("type", isBinary ? "binary" : "text");
+          shared_ptr<Microsoft::React::IWebSocketModuleContentHandler> contentHandler;
+          auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<Microsoft::React::IWebSocketModuleContentHandler>>>{
+              L"BlobModule.ContentHandler"};
+          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 = std::vector<uint8_t>(arr.begin(), arr.end());
+
+              contentHandler->ProcessMessage(std::move(data), args);
+            } else {
+              contentHandler->ProcessMessage(string{message}, args);
+            }
+          } else {
+            args["data"] = message;
+          }
 
-      auto args = dynamic::object("id", id)("data", message)("type", isBinary ? "binary" : "text");
-      SendEvent(weakInstance, "websocketMessage", std::move(args));
-    });
+          SendEvent(weakInstance, "websocketMessage", std::move(args));
+        });
     ws->SetOnClose([id, weakInstance](IWebSocketResource::CloseCode code, const string &reason) {
       auto strongInstance = weakInstance.lock();
       if (!strongInstance)
@@ -119,9 +149,24 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
 
 namespace Microsoft::React {
 
-WebSocketModule::WebSocketModule() : m_sharedState{std::make_shared<SharedState>()} {
+#pragma region WebSocketModule
+
+WebSocketModule::WebSocketModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties)
+    : m_sharedState{std::make_shared<SharedState>()},
+      m_proxy{std::make_shared<WebSocketModuleProxy>(inspectableProperties)} {
   m_sharedState->ResourceFactory = [](string &&url) { return IWebSocketResource::Make(); };
   m_sharedState->Module = this;
+  m_sharedState->InspectableProps = inspectableProperties;
+
+  auto propBag = ReactPropertyBag{m_sharedState->InspectableProps.try_as<IReactPropertyBag>()};
+
+  auto proxyPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
+  auto proxy = weak_ptr<IWebSocketModuleProxy>{m_proxy};
+  propBag.Set(proxyPropId, std::move(proxy));
+
+  auto statePropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<SharedState>>>{L"WebSocketModule.SharedState"};
+  auto state = weak_ptr<SharedState>{m_sharedState};
+  propBag.Set(statePropId, std::move(state));
 }
 
 WebSocketModule::~WebSocketModule() noexcept /*override*/ {
@@ -167,7 +212,7 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
           const auto& headersDynamic = optionsDynamic["headers"];
           for (const auto& header : headersDynamic.items())
           {
-            options.emplace(Utf8ToUtf16(header.first.getString()), header.second.getString());
+            options.emplace(winrt::to_hstring(header.first.getString()), header.second.getString());
           }
         }
 
@@ -246,12 +291,37 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
 } // getMethods
 // clang-format on
 
+#pragma endregion WebSocketModule
+
+#pragma region WebSocketModuleProxy
+
+WebSocketModuleProxy::WebSocketModuleProxy(IInspectable const &inspectableProperties) noexcept
+    : m_inspectableProps{inspectableProperties} {}
+
+void WebSocketModuleProxy::SendBinary(std::string &&base64String, int64_t id) noexcept /*override*/ {
+  auto propBag = ReactPropertyBag{m_inspectableProps.try_as<IReactPropertyBag>()};
+  auto sharedPropId =
+      ReactPropertyId<ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>>{L"WebSocketModule.SharedState"};
+  auto state = propBag.Get(sharedPropId).Value();
+
+  weak_ptr weakWs = GetOrCreateWebSocket(id, {}, std::move(state));
+  if (auto sharedWs = weakWs.lock()) {
+    sharedWs->SendBinary(std::move(base64String));
+  }
+}
+
+#pragma endregion WebSocketModuleProxy
+
 /*extern*/ const char *GetWebSocketModuleName() noexcept {
   return moduleName;
 }
 
-/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule() noexcept {
-  return std::make_unique<WebSocketModule>();
+/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule(
+    IInspectable const &inspectableProperties) noexcept {
+  if (auto properties = inspectableProperties.try_as<IReactPropertyBag>())
+    return std::make_unique<WebSocketModule>(properties);
+
+  return nullptr;
 }
 
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.h

@@ -3,11 +3,31 @@
 
 #pragma once
 
+#include <Modules/IWebSocketModuleProxy.h>
+#include <Networking/IWebSocketResource.h>
+
+// React Native
 #include <cxxreact/CxxModule.h>
-#include "IWebSocketResource.h"
+
+// Windows API
+#include <winrt/Windows.Foundation.h>
 
 namespace Microsoft::React {
 
+class WebSocketModuleProxy final : public IWebSocketModuleProxy {
+  // Property bag high level reference.
+  winrt::Windows::Foundation::IInspectable m_inspectableProps;
+
+ public:
+  WebSocketModuleProxy(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
+
+#pragma region IWebSocketModuleProxy
+
+  void SendBinary(std::string &&base64String, int64_t id) noexcept override;
+
+#pragma endregion
+};
+
 ///
 /// Realizes <c>NativeModules</c> projection.
 /// <remarks>See react-native/Libraries/WebSocket/WebSocket.js</remarks>
@@ -16,7 +36,7 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
  public:
   enum MethodId { Connect = 0, Close = 1, Send = 2, SendBinary = 3, Ping = 4, SIZE = 5 };
 
-  WebSocketModule();
+  WebSocketModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties);
 
   ~WebSocketModule() noexcept override;
 
@@ -25,17 +45,20 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
     /// 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{};
+    std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> ResourceMap{};
 
     /// <summary>
     /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
     /// </summary>
-    std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> ResourceFactory;
+    std::function<std::shared_ptr<Networking::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};
+
+    // Property bag high level reference.
+    winrt::Windows::Foundation::IInspectable InspectableProps;
   };
 
 #pragma region CxxModule overrides
@@ -58,19 +81,25 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
 
 #pragma endregion CxxModule overrides
 
-  void SetResourceFactory(std::function<std::shared_ptr<IWebSocketResource>(const std::string &)> &&resourceFactory);
+  void SetResourceFactory(
+      std::function<std::shared_ptr<Networking::IWebSocketResource>(const std::string &)> &&resourceFactory);
 
  private:
   /// <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>> m_webSockets;
+  std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> m_webSockets;
 
   /// <summary>
   /// Keeps members that can be accessed threads other than this module's owner accessible.
   /// </summary>
   std::shared_ptr<SharedState> m_sharedState;
+
+  /// <summary>
+  /// Exposes a subset of the module's methods.
+  /// </summary>
+  std::shared_ptr<IWebSocketModuleProxy> m_proxy;
 };
 
 } // namespace Microsoft::React

package/Shared/Networking/IHttpResource.h

@@ -0,0 +1,101 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Folly
+#include <folly/dynamic.h>
+
+// Windows API
+#include <winrt/Windows.Foundation.h>
+
+// Standard Library
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace Microsoft::React::Networking {
+
+struct IHttpResource {
+  typedef std::unordered_map<std::string, std::string> Headers;
+
+  // TODO: Implement Form data
+  struct BodyData {
+    enum class Type : size_t { Empty, String, Base64, Uri, Form } Type = Type::Empty;
+    std::string Data;
+  };
+
+  struct Response {
+    int64_t StatusCode;
+    std::string Url;
+    Headers Headers;
+  };
+
+  static std::shared_ptr<IHttpResource> Make() noexcept;
+
+  static std::shared_ptr<IHttpResource> Make(
+      winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
+
+  virtual ~IHttpResource() noexcept {}
+
+  /// <summary>
+  /// Initiates an HTTP request.
+  /// </summary>
+  /// <param name="method">
+  /// HTTP verb to send in de request.
+  /// GET | POST | PUT | DELETE | OPTIONS
+  /// </param>
+  /// <param name="url">
+  /// Server/service remote endpoint to send the request to.
+  /// </param>
+  /// <param name="requestId">
+  /// Request unique identifier.
+  /// </param>
+  /// <param name="headers">
+  /// HTTP request header map.
+  /// </param>
+  /// <param name="data">
+  /// Dynamic map containing request payload.
+  /// The payload may be an empty request body or one of the following:
+  /// "string"  - UTF-8 string payload
+  /// "base64"  - Base64-encoded data string
+  /// "uri"     - URI data reference
+  /// "form"    - Form-encoded data
+  /// </param>
+  /// <param name="responseType">
+  /// text | binary | blob
+  /// </param>
+  /// <param name="useIncrementalUpdates">
+  /// Response body to be retrieved in several iterations.
+  /// </param>
+  /// <param name="timeout">
+  /// Request timeout in miliseconds.
+  /// </param>
+  /// <param name="withCredentials">
+  /// Allow including credentials in request.
+  /// </param>
+  virtual void SendRequest(
+      std::string &&method,
+      std::string &&url,
+      int64_t requestId,
+      Headers &&headers,
+      folly::dynamic &&data,
+      std::string &&responseType,
+      bool useIncrementalUpdates,
+      int64_t timeout,
+      bool withCredentials,
+      std::function<void(int64_t)> &&callback) noexcept = 0;
+  virtual void AbortRequest(int64_t requestId) noexcept = 0;
+
+  virtual void ClearCookies() noexcept = 0;
+
+  virtual void SetOnRequestSuccess(std::function<void(int64_t requestId)> &&handler) noexcept = 0;
+  virtual void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept = 0;
+  virtual void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept = 0;
+  virtual void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept = 0;
+  virtual void SetOnError(
+      std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)> &&handler) noexcept = 0;
+};
+
+} // namespace Microsoft::React::Networking

package/Shared/{IWebSocketResource.h → Networking/IWebSocketResource.h}

@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 
-namespace Microsoft::React {
+namespace Microsoft::React::Networking {
 
 /// <summary>
 /// Defines the core functionality for a native WebSocket client resource.
@@ -181,4 +181,4 @@ struct IWebSocketResource {
   virtual void SetOnError(std::function<void(Error &&)> &&handler) noexcept = 0;
 };
 
-} // namespace Microsoft::React
+} // namespace Microsoft::React::Networking

package/Shared/Networking/OriginPolicy.h

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+namespace Microsoft::React::Networking {
+
+enum class OriginPolicy : size_t {
+  None = 0,
+  SameOrigin = 1,
+  SimpleCrossOriginResourceSharing = 2,
+  CrossOriginResourceSharing = 3, // TODO: Rename as FullCrossOriginResourceSharing?
+};
+
+} // namespace Microsoft::React::Networking