react-native-windows 0.72.1 → 0.72.3

package/Shared/CreateModules.h

@@ -5,7 +5,6 @@
 
 // React Native
 #include <cxxreact/CxxModule.h>
-#include <smartPtr/cntPtr.h>
 
 // Windows API
 #include <winrt/Windows.Foundation.h>
@@ -14,12 +13,16 @@
 #include <memory>
 
 // Forward declarations. Desktop projects can not access <React.h>
+namespace winrt::Microsoft::ReactNative {
+struct ReactContext;
+struct ReactModuleProvider;
+} // namespace winrt::Microsoft::ReactNative
+
 namespace Mso::React {
 struct IReactContext;
 }
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class MessageQueueThread;
 
@@ -29,11 +32,12 @@ class MessageQueueThread;
 extern std::unique_ptr<facebook::xplat::module::CxxModule> CreateTimingModule(
     const std::shared_ptr<facebook::react::MessageQueueThread> &nativeThread) noexcept;
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react
 
 namespace Microsoft::React {
 
+#pragma region CxxModules
+
 extern const char *GetHttpModuleName() noexcept;
 extern std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
     winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
@@ -50,4 +54,22 @@ extern const char *GetFileReaderModuleName() noexcept;
 extern std::unique_ptr<facebook::xplat::module::CxxModule> CreateFileReaderModule(
     winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept;
 
+#pragma endregion CxxModules
+
+#pragma region TurboModules
+
+extern const wchar_t *GetBlobTurboModuleName() noexcept;
+extern const winrt::Microsoft::ReactNative::ReactModuleProvider &GetBlobModuleProvider() noexcept;
+
+extern const wchar_t *GetHttpTurboModuleName() noexcept;
+extern const winrt::Microsoft::ReactNative::ReactModuleProvider &GetHttpModuleProvider() noexcept;
+
+extern const wchar_t *GetFileReaderTurboModuleName() noexcept;
+extern const winrt::Microsoft::ReactNative::ReactModuleProvider &GetFileReaderModuleProvider() noexcept;
+
+extern const wchar_t *GetWebSocketTurboModuleName() noexcept;
+extern const winrt::Microsoft::ReactNative::ReactModuleProvider &GetWebSocketModuleProvider() noexcept;
+
+#pragma endregion TurboModules
+
 } // namespace Microsoft::React

package/Shared/IFileReaderResource.h

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IBlobPersistor.h"
+
+// Standard Library
+#include <functional>
+#include <string>
+
+namespace Microsoft::React {
+
+struct IFileReaderResource {
+  virtual ~IFileReaderResource() noexcept {}
+
+  virtual void ReadAsText(
+      std::string &&blobId,
+      int64_t offset,
+      int64_t size,
+      std::string &&encoding,
+      std::function<void(std::string &&)> &&resolver,
+      std::function<void(std::string &&)> &&rejecter) noexcept = 0;
+
+  virtual void ReadAsDataUrl(
+      std::string &&blobId,
+      int64_t offset,
+      int64_t size,
+      std::string &&type,
+      std::function<void(std::string &&)> &&resolver,
+      std::function<void(std::string &&)> &&rejecter) noexcept = 0;
+
+  static std::shared_ptr<IFileReaderResource> Make(std::weak_ptr<IBlobPersistor> weakBlobPersistor) noexcept;
+};
+
+} // namespace Microsoft::React

package/Shared/Modules/BlobModule.cpp

@@ -3,208 +3,145 @@
 
 #include "BlobModule.h"
 
+#include <CreateModules.h>
 #include <Modules/CxxModuleUtilities.h>
-#include <Modules/IHttpModuleProxy.h>
-#include <Modules/IWebSocketModuleProxy.h>
-#include <ReactPropertyBag.h>
-#include <unicode.h>
 
 // React Native
 #include <cxxreact/JsArgumentHelpers.h>
 
-// Windows API
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.Security.Cryptography.h>
-
-// Standard Library
-#include <chrono>
-#include <filesystem>
-#include <fstream>
-
 using namespace facebook::xplat;
 
 using folly::dynamic;
-using std::scoped_lock;
-using std::shared_ptr;
+using Microsoft::React::Networking::IBlobResource;
 using std::string;
 using std::vector;
-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::GuidHelper;
 using winrt::Windows::Foundation::IInspectable;
-using winrt::Windows::Foundation::Uri;
-using winrt::Windows::Security::Cryptography::CryptographicBuffer;
 
-namespace fs = std::filesystem;
+namespace msrn = winrt::Microsoft::ReactNative;
 
 namespace {
-constexpr char moduleName[] = "BlobModule";
-constexpr char blobKey[] = "blob";
-constexpr char blobIdKey[] = "blobId";
-constexpr char offsetKey[] = "offset";
-constexpr char sizeKey[] = "size";
-constexpr char typeKey[] = "type";
-constexpr char dataKey[] = "data";
+constexpr char s_moduleName[] = "BlobModule";
+constexpr wchar_t s_moduleNameW[] = L"BlobModule";
+
+const auto &blobKeys = IBlobResource::FieldNames();
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::BlobTurboModule>();
+
 } // namespace
 
 namespace Microsoft::React {
 
-#pragma region BlobModule
+#pragma region BlobTurboModule
 
-BlobModule::BlobModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept
-    : m_sharedState{std::make_shared<SharedState>()},
-      m_blobPersistor{std::make_shared<MemoryBlobPersistor>()},
-      m_contentHandler{std::make_shared<BlobWebSocketModuleContentHandler>(m_blobPersistor)},
-      m_requestBodyHandler{std::make_shared<BlobModuleRequestBodyHandler>(m_blobPersistor)},
-      m_responseHandler{std::make_shared<BlobModuleResponseHandler>(m_blobPersistor)},
-      m_inspectableProperties{inspectableProperties} {
-  auto propBag = ReactPropertyBag{m_inspectableProperties.try_as<IReactPropertyBag>()};
-
-  auto contentHandlerPropId =
-      ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
-  auto contentHandler = weak_ptr<IWebSocketModuleContentHandler>{m_contentHandler};
-  propBag.Set(contentHandlerPropId, std::move(contentHandler));
-
-  auto blobPersistorPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
-  auto blobPersistor = weak_ptr<IBlobPersistor>{m_blobPersistor};
-  propBag.Set(blobPersistorPropId, std::move(blobPersistor));
-
-  m_sharedState->Module = this;
+void BlobTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  m_resource = IBlobResource::Make(reactContext.Properties().Handle());
+  m_resource->Callbacks().OnError = [&reactContext](string &&errorText) {
+    Modules::SendEvent(reactContext, L"blobFailed", {errorText});
+  };
+}
+
+ReactNativeSpecs::BlobModuleSpec_Constants BlobTurboModule::GetConstants() noexcept {
+  ReactNativeSpecs::BlobModuleSpec_Constants result;
+  result.BLOB_URI_SCHEME = blobKeys.Blob;
+  result.BLOB_URI_HOST = {};
+
+  return result;
+}
+
+void BlobTurboModule::AddNetworkingHandler() noexcept {
+  m_resource->AddNetworkingHandler();
+}
+
+void BlobTurboModule::AddWebSocketHandler(double id) noexcept {
+  m_resource->AddWebSocketHandler(static_cast<int64_t>(id));
+}
+
+void BlobTurboModule::RemoveWebSocketHandler(double id) noexcept {
+  m_resource->RemoveWebSocketHandler(static_cast<int64_t>(id));
+}
+
+void BlobTurboModule::SendOverSocket(msrn::JSValue &&blob, double socketID) noexcept {
+  m_resource->SendOverSocket(
+      blob[blobKeys.BlobId].AsString(),
+      blob[blobKeys.Offset].AsInt64(),
+      blob[blobKeys.Size].AsInt64(),
+      static_cast<int64_t>(socketID));
+}
+
+void BlobTurboModule::CreateFromParts(vector<msrn::JSValue> &&parts, string &&withId) noexcept {
+  m_resource->CreateFromParts(std::move(parts), std::move(withId));
 }
 
-BlobModule::~BlobModule() noexcept /*override*/ {
-  m_sharedState->Module = nullptr;
+void BlobTurboModule::Release(string &&blobId) noexcept {
+  m_resource->Release(std::move(blobId));
 }
 
+#pragma endregion BlobTurboModule
+
+#pragma region BlobModule
+
+BlobModule::BlobModule(winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept
+    : m_resource{IBlobResource::Make(inspectableProperties)} {}
+
 #pragma region CxxModule
 
 string BlobModule::getName() {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> BlobModule::getConstants() {
-  return {{"BLOB_URI_SCHEME", blobKey}, {"BLOB_URI_HOST", {}}};
+  return {{"BLOB_URI_SCHEME", blobKeys.Blob}, {"BLOB_URI_HOST", {}}};
 }
 
 vector<module::CxxModule::Method> BlobModule::getMethods() {
+  // See CxxNativeModule::lazyInit()
+  m_resource->Callbacks().OnError = [weakInstance = getInstance()](string &&errorText) {
+    Modules::SendEvent(weakInstance, "blobFailed", std::move(errorText));
+  };
+
   return {
-      {"addNetworkingHandler",
-       [propBag = ReactPropertyBag{m_inspectableProperties.try_as<IReactPropertyBag>()},
-        requestBodyHandler = m_requestBodyHandler,
-        responseHandler = m_responseHandler](dynamic args) {
-         auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
-
-         if (auto prop = propBag.Get(propId)) {
-           if (auto httpHandler = prop.Value().lock()) {
-             httpHandler->AddRequestBodyHandler(requestBodyHandler);
-             httpHandler->AddResponseHandler(responseHandler);
-           }
-         }
-         // TODO: else emit error?
-       }},
+      {"addNetworkingHandler", [resource = m_resource](dynamic /*args*/) { resource->AddNetworkingHandler(); }},
 
       {"addWebSocketHandler",
-       [contentHandler = m_contentHandler](dynamic args) {
+       [resource = m_resource](dynamic args) {
          auto id = jsArgAsInt(args, 0);
 
-         contentHandler->Register(id);
+         resource->AddWebSocketHandler(id);
        }},
 
       {"removeWebSocketHandler",
-       [contentHandler = m_contentHandler](dynamic args) {
+       [resource = m_resource](dynamic args) {
          auto id = jsArgAsInt(args, 0);
 
-         contentHandler->Unregister(id);
+         resource->RemoveWebSocketHandler(id);
        }},
 
       {"sendOverSocket",
-       [weakState = weak_ptr<SharedState>(m_sharedState),
-        persistor = m_blobPersistor,
-        propBag = ReactPropertyBag{m_inspectableProperties.try_as<IReactPropertyBag>()}](dynamic args) {
-         auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
-         shared_ptr<IWebSocketModuleProxy> wsProxy;
-         if (auto prop = propBag.Get(propId)) {
-           wsProxy = prop.Value().lock();
-         }
-         if (!wsProxy) {
-           return;
-         }
-
+       [resource = m_resource](dynamic args) {
          auto blob = jsArgAsObject(args, 0);
-         auto blobId = blob[blobIdKey].getString();
-         auto offset = blob[offsetKey].getInt();
-         auto size = blob[sizeKey].getInt();
-         auto socketID = jsArgAsInt(args, 1);
-
-         winrt::array_view<uint8_t const> data;
-         try {
-           data = persistor->ResolveMessage(std::move(blobId), offset, size);
-         } catch (const std::exception &e) {
-           if (auto sharedState = weakState.lock()) {
-             Modules::SendEvent(sharedState->Module->getInstance(), "blobFailed", e.what());
-           }
-           return;
-         }
-
-         auto buffer = CryptographicBuffer::CreateFromByteArray(data);
-         auto winrtString = CryptographicBuffer::EncodeToBase64String(std::move(buffer));
-         auto base64String = Common::Unicode::Utf16ToUtf8(std::move(winrtString));
-
-         wsProxy->SendBinary(std::move(base64String), socketID);
+         auto blobId = blob[blobKeys.BlobId].getString();
+         auto offset = blob[blobKeys.Offset].getInt();
+         auto size = blob[blobKeys.Size].getInt();
+         auto socketId = jsArgAsInt(args, 1);
+
+         resource->SendOverSocket(std::move(blobId), offset, size, socketId);
        }},
 
       {"createFromParts",
-       // As of React Native 0.67, instance is set AFTER CxxModule::getMethods() is invoked.
-       // Use getInstance() directly once
-       // https://github.com/facebook/react-native/commit/1d45b20b6c6ba66df0485cdb9be36463d96cf182 becomes available.
-       [persistor = m_blobPersistor, weakState = weak_ptr<SharedState>(m_sharedState)](dynamic args) {
-         auto parts = jsArgAsArray(args, 0); // Array<Object>
+       [resource = m_resource](dynamic args) {
+         auto dynamicParts = jsArgAsArray(args, 0); // Array<Object>
+         auto parts = Modules::ToJSValue(dynamicParts);
          auto blobId = jsArgAsString(args, 1);
-         vector<uint8_t> buffer{};
-
-         for (const auto &part : parts) {
-           auto type = part[typeKey].asString();
-           if (blobKey == type) {
-             auto blob = part[dataKey];
-             winrt::array_view<uint8_t const> bufferPart;
-             try {
-               bufferPart = persistor->ResolveMessage(
-                   blob[blobIdKey].asString(), blob[offsetKey].asInt(), blob[sizeKey].asInt());
-             } catch (const std::exception &e) {
-               if (auto sharedState = weakState.lock()) {
-                 Modules::SendEvent(sharedState->Module->getInstance(), "blobFailed", e.what());
-               }
-               return;
-             }
-
-             buffer.reserve(buffer.size() + bufferPart.size());
-             buffer.insert(buffer.end(), bufferPart.begin(), bufferPart.end());
-           } else if ("string" == type) {
-             auto data = part[dataKey].asString();
-
-             buffer.reserve(buffer.size() + data.size());
-             buffer.insert(buffer.end(), data.begin(), data.end());
-           } else {
-             if (auto state = weakState.lock()) {
-               auto message = "Invalid type for blob: " + type;
-               Modules::SendEvent(state->Module->getInstance(), "blobFailed", std::move(message));
-             }
-             return;
-           }
-         }
-
-         persistor->StoreMessage(std::move(buffer), std::move(blobId));
+
+         resource->CreateFromParts(parts.MoveArray(), std::move(blobId));
        }},
 
       {"release",
-       [persistor = m_blobPersistor](dynamic args) // blobId: string
+       [resource = m_resource](dynamic args) // blobId: string
        {
          auto blobId = jsArgAsString(args, 0);
 
-         persistor->RemoveMessage(std::move(blobId));
+         resource->Release(std::move(blobId));
        }}};
 }
 
@@ -212,165 +149,24 @@ vector<module::CxxModule::Method> BlobModule::getMethods() {
 
 #pragma endregion BlobModule
 
-#pragma region MemoryBlobPersistor
-
-#pragma region IBlobPersistor
-
-winrt::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 winrt::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 {
-  // substr(1, 36) strips curly braces from a GUID.
-  auto blobId = winrt::to_string(winrt::to_hstring(GuidHelper::CreateNewGuid())).substr(1, 36);
-
-  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, dynamic &params) /*override*/ {
-  params[dataKey] = std::move(message);
-}
-
-void BlobWebSocketModuleContentHandler::ProcessMessage(vector<uint8_t> &&message, dynamic &params) /*override*/ {
-  auto blob = dynamic::object();
-  blob(offsetKey, 0);
-  blob(sizeKey, message.size());
-  blob(blobIdKey, m_blobPersistor->StoreMessage(std::move(message)));
-
-  params[dataKey] = std::move(blob);
-  params[typeKey] = blobKey;
-}
-#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(dynamic &data) /*override*/ {
-  auto itr = data.find(blobKey);
-
-  return itr != data.items().end() && !(*itr).second.empty();
-}
-
-dynamic BlobModuleRequestBodyHandler::ToRequestBody(dynamic &data, string &contentType) /*override*/ {
-  auto type = contentType;
-  if (!data[typeKey].isNull() && !data[typeKey].asString().empty()) {
-    type = data[typeKey].asString();
-  }
-  if (type.empty()) {
-    type = "application/octet-stream";
-  }
-
-  auto blob = data[blobKey];
-  auto blobId = blob[blobIdKey].asString();
-  auto bytes = m_blobPersistor->ResolveMessage(std::move(blobId), blob[offsetKey].asInt(), blob[sizeKey].asInt());
-
-  auto result = dynamic::object();
-  result(typeKey, type);
-  result(sizeKey, bytes.size());
-  result("bytes", dynamic(bytes.cbegin(), bytes.cend()));
-
-  return result;
-}
-
-#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 blobKey == responseType;
-}
-
-dynamic BlobModuleResponseHandler::ToResponseData(vector<uint8_t> &&content) /*override*/ {
-  auto blob = dynamic::object();
-  blob(offsetKey, 0);
-  blob(sizeKey, content.size());
-  blob(blobIdKey, m_blobPersistor->StoreMessage(std::move(content)));
-
-  return blob;
-}
-
-#pragma endregion IResponseHandler
-
-#pragma endregion BlobModuleResponseHandler
-
 /*extern*/ const char *GetBlobModuleName() noexcept {
-  return moduleName;
+  return s_moduleName;
 }
 
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateBlobModule(
     IInspectable const &inspectableProperties) noexcept {
-  if (auto properties = inspectableProperties.try_as<IReactPropertyBag>())
+  if (auto properties = inspectableProperties.try_as<msrn::IReactPropertyBag>())
     return std::make_unique<BlobModule>(properties);
 
   return nullptr;
 }
 
+/*extern*/ const wchar_t *GetBlobTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetBlobModuleProvider() noexcept {
+  return s_moduleProvider;
+}
+
 } // namespace Microsoft::React