react-native-windows 0.72.1 → 0.72.3

package/Shared/Modules/BlobModule.h

@@ -3,10 +3,9 @@
 
 #pragma once
 
-#include <Modules/IBlobPersistor.h>
-#include <Modules/IRequestBodyHandler.h>
-#include <Modules/IResponseHandler.h>
-#include <Modules/IWebSocketModuleContentHandler.h>
+#include <NativeBlobModuleSpec.g.h>
+
+#include <Networking/IBlobResource.h>
 
 // React Native
 #include <cxxreact/CxxModule.h>
@@ -15,91 +14,45 @@
 #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 const> 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;
+REACT_MODULE(BlobTurboModule, L"BlobModule")
+struct BlobTurboModule {
+  using ModuleSpec = ReactNativeSpecs::BlobModuleSpec;
 
-  void Unregister(int64_t socketID) noexcept;
-};
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
-class BlobModuleRequestBodyHandler final : public IRequestBodyHandler {
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+  REACT_GET_CONSTANTS(GetConstants)
+  ReactNativeSpecs::BlobModuleSpec_Constants GetConstants() noexcept;
 
- public:
-  BlobModuleRequestBodyHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+  REACT_METHOD(AddNetworkingHandler, L"addNetworkingHandler")
+  void AddNetworkingHandler() noexcept;
 
-#pragma region IRequestBodyHandler
+  REACT_METHOD(AddWebSocketHandler, L"addWebSocketHandler")
+  void AddWebSocketHandler(double id) noexcept;
 
-  bool Supports(folly::dynamic &data) override;
+  REACT_METHOD(RemoveWebSocketHandler, L"removeWebSocketHandler")
+  void RemoveWebSocketHandler(double id) noexcept;
 
-  folly::dynamic ToRequestBody(folly::dynamic &data, std::string &contentType) override;
+  REACT_METHOD(SendOverSocket, L"sendOverSocket")
+  void SendOverSocket(winrt::Microsoft::ReactNative::JSValue &&blob, double socketID) noexcept;
 
-#pragma endregion IRequestBodyHandler
-};
+  REACT_METHOD(CreateFromParts, L"createFromParts")
+  void CreateFromParts(std::vector<winrt::Microsoft::ReactNative::JSValue> &&parts, std::string &&withId) noexcept;
 
-class BlobModuleResponseHandler final : public IResponseHandler {
-  std::shared_ptr<IBlobPersistor> m_blobPersistor;
-
- public:
-  BlobModuleResponseHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+  REACT_METHOD(Release, L"release")
+  void Release(std::string &&blobId) noexcept;
 
-#pragma region IResponseHandler
-
-  bool Supports(std::string &responseType) override;
-
-  folly::dynamic ToResponseData(std::vector<uint8_t> &&content) override;
-
-#pragma endregion IResponseHandler
+ private:
+  std::shared_ptr<Networking::IBlobResource> m_resource;
 };
 
 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;
+  std::shared_ptr<Networking::IBlobResource> m_resource;
 
  public:
   enum class MethodId {
@@ -114,15 +67,6 @@ class BlobModule : public facebook::xplat::module::CxxModule {
 
   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>
@@ -142,12 +86,6 @@ class BlobModule : public facebook::xplat::module::CxxModule {
   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

@@ -2,6 +2,10 @@
 // Licensed under the MIT License.
 
 #include "CxxModuleUtilities.h"
+#include <DynamicReader.h>
+#include <DynamicWriter.h>
+
+namespace msrn = winrt::Microsoft::ReactNative;
 
 using facebook::react::Instance;
 using folly::dynamic;
@@ -16,4 +20,32 @@ void SendEvent(weak_ptr<Instance> weakReactInstance, string &&eventName, dynamic
   }
 }
 
+void SendEvent(
+    msrn::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    msrn::JSValueObject &&args) noexcept {
+  reactContext.EmitJSEvent(L"RCTDeviceEventEmitter", std::move(eventName), std::move(args));
+}
+
+void SendEvent(
+    msrn::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    msrn::JSValueArray &&args) noexcept {
+  reactContext.EmitJSEvent(L"RCTDeviceEventEmitter", std::move(eventName), std::move(args));
+}
+
+msrn::JSValue ToJSValue(dynamic &value) noexcept {
+  auto reader = winrt::make<msrn::DynamicReader>(value);
+  auto result = msrn::JSValue::ReadFrom(reader);
+
+  return result;
+}
+
+dynamic ToDynamic(const msrn::JSValue &value) noexcept {
+  auto argWriter = msrn::MakeJSValueArgWriter(value);
+  auto result = msrn::DynamicWriter::ToDynamic(argWriter)[0];
+
+  return result;
+}
+
 } // namespace Microsoft::React::Modules

package/Shared/Modules/CxxModuleUtilities.h

@@ -9,6 +9,9 @@
 // React Native
 #include <cxxreact/Instance.h>
 
+// React Native Windows
+#include <ReactContext.h>
+
 // Standard Library
 #include <memory>
 #include <string>
@@ -20,4 +23,18 @@ void SendEvent(
     std::string &&eventName,
     folly::dynamic &&args);
 
+void SendEvent(
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    winrt::Microsoft::ReactNative::JSValueObject &&args) noexcept;
+
+void SendEvent(
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext,
+    std::wstring_view &&eventName,
+    winrt::Microsoft::ReactNative::JSValueArray &&args) noexcept;
+
+winrt::Microsoft::ReactNative::JSValue ToJSValue(folly::dynamic &value) noexcept;
+
+folly::dynamic ToDynamic(const winrt::Microsoft::ReactNative::JSValue &value) noexcept;
+
 } // namespace Microsoft::React::Modules

package/Shared/Modules/FileReaderModule.cpp

@@ -3,6 +3,7 @@
 
 #include "FileReaderModule.h"
 
+#include <CreateModules.h>
 #include <ReactPropertyBag.h>
 #include <sstream>
 
@@ -19,17 +20,18 @@
 
 using namespace facebook::xplat;
 
+namespace msrn = winrt::Microsoft::ReactNative;
+
 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";
+constexpr char s_moduleName[] = "FileReaderModule";
+constexpr wchar_t s_moduleNameW[] = L"FileReaderModule";
+
+msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::FileReaderTurboModule>();
 } // namespace
 
 namespace Microsoft::React {
@@ -37,7 +39,7 @@ namespace Microsoft::React {
 #pragma region FileReaderModule
 
 FileReaderModule::FileReaderModule(weak_ptr<IBlobPersistor> weakBlobPersistor) noexcept
-    : m_weakBlobPersistor{weakBlobPersistor} {}
+    : m_resource{IFileReaderResource::Make(weakBlobPersistor)} {}
 
 FileReaderModule::~FileReaderModule() noexcept /*override*/
 {}
@@ -45,7 +47,7 @@ FileReaderModule::~FileReaderModule() noexcept /*override*/
 #pragma region CxxModule
 
 string FileReaderModule::getName() {
-  return moduleName;
+  return s_moduleName;
 }
 
 std::map<string, dynamic> FileReaderModule::getConstants() {
@@ -61,41 +63,28 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
        /// </param>
        ///
        "readAsDataURL",
-       [blobPersistor = m_weakBlobPersistor.lock()](dynamic args, Callback resolve, Callback reject) {
-         if (!blobPersistor) {
-           return reject({"Could not find Blob persistor"});
-         }
-
+       [resource = m_resource](dynamic args, Callback resolve, Callback reject) {
          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 const> 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");
+         string type{};
          if (typeItr == blob.items().end()) {
-           result += "application/octet-stream";
+           type = "application/octet-stream";
          } else {
-           result += (*typeItr).second.asString();
+           type = (*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)});
+         resource->ReadAsDataUrl(
+             std::move(blobId),
+             offset,
+             size,
+             std::move(type),
+             [&resolve](string &&message) { resolve({std::move(message)}); },
+             [&reject](string &&message) { reject({std::move(message)}); });
        }},
       {///
        /// <param name="args">
@@ -105,11 +94,7 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
        /// </param>
        ///
        "readAsText",
-       [blobPersistor = m_weakBlobPersistor.lock()](dynamic args, Callback resolve, Callback reject) {
-         if (!blobPersistor) {
-           return reject({"Could not find Blob persistor"});
-         }
-
+       [resource = m_resource](dynamic args, Callback resolve, Callback reject) {
          auto blob = jsArgAsObject(args, 0);
          auto encoding = jsArgAsString(args, 1); // Default: "UTF-8"
 
@@ -117,18 +102,13 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
          auto offset = blob["offset"].asInt();
          auto size = blob["size"].asInt();
 
-         winrt::array_view<uint8_t const> 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)});
+         resource->ReadAsText(
+             std::move(blobId),
+             offset,
+             size,
+             std::move(encoding),
+             [&resolve](string &&message) { resolve({std::move(message)}); },
+             [&reject](string &&message) { reject({std::move(message)}); });
        }}};
 }
 
@@ -136,14 +116,93 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
 
 #pragma endregion FileReaderModule
 
+#pragma region FileReaderTurboModule
+
+void FileReaderTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
+  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  auto props = reactContext.Properties();
+  auto prop = props.Get(propId);
+  m_resource = IFileReaderResource::Make(prop.Value());
+}
+
+///
+/// <param name="data">
+/// Blob object with the following fields:
+/// - blobId
+/// - offset
+/// - size
+/// - type (optional)
+/// </param>
+/// <param name="result">
+/// Either resolves or rejects the current method with a given text message.
+/// </param>
+///
+void FileReaderTurboModule::ReadAsDataUrl(msrn::JSValue &&data, msrn::ReactPromise<string> &&result) noexcept {
+  auto &blob = data.AsObject();
+  auto blobId = blob["blobId"].AsString();
+  auto offset = blob["offset"].AsInt64();
+  auto size = blob["size"].AsInt64();
+
+  auto typeItr = blob.find("type");
+  string type{};
+  if (typeItr == blob.end()) {
+    type = "application/octet-stream";
+  } else {
+    type = (*typeItr).second.AsString();
+  }
+
+  m_resource->ReadAsDataUrl(
+      std::move(blobId),
+      offset,
+      size,
+      std::move(type),
+      [&result](string &&message) { result.Resolve(std::move(message)); },
+      [&result](string &&message) { result.Reject(winrt::to_hstring(std::move(message)).c_str()); });
+}
+
+///
+/// <param name="data">
+/// Blob object with the following fields:
+/// - blobId
+/// - offset
+/// - size
+/// - type (optional)
+/// </param>
+/// <param name="encoding">
+/// Text encoding to proces data with.
+/// </param>
+/// <param name="result">
+/// Either resolves or rejects the current method with a given text message.
+/// </param>
+///
+void FileReaderTurboModule::ReadAsText(
+    msrn::JSValue &&data,
+    string &&encoding,
+    msrn::ReactPromise<string> &&result) noexcept {
+  auto &blob = data.AsObject();
+  auto blobId = blob["blobId"].AsString();
+  auto offset = blob["offset"].AsInt64();
+  auto size = blob["size"].AsInt64();
+
+  m_resource->ReadAsText(
+      std::move(blobId),
+      offset,
+      size,
+      std::move(encoding),
+      [&result](string &&message) { result.Resolve(std::move(message)); },
+      [&result](string &&message) { result.Reject(winrt::to_hstring(std::move(message)).c_str()); });
+}
+
+#pragma endregion FileReaderTurboModule
+
 /*extern*/ const char *GetFileReaderModuleName() noexcept {
-  return moduleName;
+  return s_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>()};
+  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
+  auto propBag = msrn::ReactPropertyBag{inspectableProperties.try_as<msrn::IReactPropertyBag>()};
 
   if (auto prop = propBag.Get(propId)) {
     auto weakBlobPersistor = prop.Value();
@@ -154,4 +213,12 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
   return nullptr;
 }
 
+/*extern*/ const wchar_t *GetFileReaderTurboModuleName() noexcept {
+  return s_moduleNameW;
+}
+
+/*extern*/ const msrn::ReactModuleProvider &GetFileReaderModuleProvider() noexcept {
+  return s_moduleProvider;
+}
+
 } // namespace Microsoft::React

package/Shared/Modules/FileReaderModule.h

@@ -3,6 +3,10 @@
 
 #pragma once
 
+#include <NativeFileReaderModuleSpec.g.h>
+
+#include <IFileReaderResource.h>
+#include <NativeModules.h>
 #include "IBlobPersistor.h"
 
 // React Native
@@ -48,7 +52,29 @@ class FileReaderModule : public facebook::xplat::module::CxxModule {
 #pragma endregion CxxModule
 
  private:
-  std::weak_ptr<IBlobPersistor> m_weakBlobPersistor;
+  std::shared_ptr<IFileReaderResource> m_resource;
+};
+
+REACT_MODULE(FileReaderTurboModule, L"FileReaderModule")
+struct FileReaderTurboModule {
+  using ModuleSpec = ReactNativeSpecs::FileReaderModuleSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  REACT_METHOD(ReadAsDataUrl, L"readAsDataURL")
+  void ReadAsDataUrl(
+      winrt::Microsoft::ReactNative::JSValue &&data,
+      winrt::Microsoft::ReactNative::ReactPromise<std::string> &&result) noexcept;
+
+  REACT_METHOD(ReadAsText, L"readAsText")
+  void ReadAsText(
+      winrt::Microsoft::ReactNative::JSValue &&data,
+      std::string &&encoding,
+      winrt::Microsoft::ReactNative::ReactPromise<std::string> &&result) noexcept;
+
+ private:
+  std::shared_ptr<IFileReaderResource> m_resource;
 };
 
 } // namespace Microsoft::React