react-native-windows 0.74.7 → 0.74.9

package/Microsoft.ReactNative/Fabric/Composition/UriImageManager.cpp

@@ -5,11 +5,19 @@
 #include "UriImageManager.h"
 
 #include "Composition.ImageSource.g.h"
+#include <Composition.Experimental.UriBrushFactoryImageResponse.g.cpp>
+#include <Composition.ImageFailedResponse.g.cpp>
+#include <Composition.ImageResponse.g.cpp>
+#include <Composition.StreamImageResponse.g.cpp>
+#include <Composition.UriBrushFactoryImageResponse.g.cpp>
 #include <AutoDraw.h>
+#include <IBlobPersistor.h>
+#include <Networking/NetworkPropertyIds.h>
 #include <ReactPropertyBag.h>
 #include <d2d1_3.h>
 #include <shcore.h>
 #include <winrt/Microsoft.ReactNative.Composition.Experimental.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
 #include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Storage.Streams.h>
 
@@ -54,16 +62,14 @@ winrt::Microsoft::ReactNative::Composition::ImageSource MakeImageSource(
  *   />
  *
  */
-struct SvgDataImageHandler : winrt::implements<
-                                 SvgDataImageHandler,
-                                 winrt::Microsoft::ReactNative::Composition::Experimental::IUriBrushProvider,
-                                 winrt::Microsoft::ReactNative::Composition::IUriImageProvider> {
+struct SvgDataImageHandler
+    : winrt::implements<SvgDataImageHandler, winrt::Microsoft::ReactNative::Composition::IUriImageProvider> {
   bool CanLoadImageUri(winrt::Microsoft::ReactNative::IReactContext context, winrt::Windows::Foundation::Uri uri) {
     return uri.SchemeName() == L"data" && std::wstring_view(uri.Path()).starts_with(L"image/svg+xml;base64,");
   }
 
-  winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory>
-  GetSourceAsync(
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
+  GetImageResponseAsync(
       const winrt::Microsoft::ReactNative::IReactContext &context,
       const winrt::Microsoft::ReactNative::Composition::ImageSource &imageSource) {
     auto path = winrt::to_string(imageSource.Uri().Path());
@@ -85,7 +91,7 @@ struct SvgDataImageHandler : winrt::implements<
       co_await memoryStream.WriteAsync(buffer);
       memoryStream.Seek(0);
 
-      co_return
+      co_return winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactoryImageResponse(
           [memoryStream, size, scale](
               const winrt::Microsoft::ReactNative::IReactContext &reactContext,
               const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compositionContext)
@@ -126,12 +132,13 @@ struct SvgDataImageHandler : winrt::implements<
             renderTarget->SetTransform(originalTransform);
 
             return drawingBrush;
-          };
+          });
 
-    } catch (winrt::hresult_error const &) {
+    } catch (winrt::hresult_error const &ex) {
+      co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(ex.message());
     }
 
-    co_return nullptr;
+    winrt::throw_hresult(E_UNEXPECTED);
   }
 };
 
@@ -145,15 +152,14 @@ struct SvgDataImageHandler : winrt::implements<
  *   />
  *
  */
-struct DataImageHandler : winrt::implements<
-                              DataImageHandler,
-                              winrt::Microsoft::ReactNative::Composition::IUriImageStreamProvider,
-                              winrt::Microsoft::ReactNative::Composition::IUriImageProvider> {
+struct DataImageHandler
+    : winrt::implements<DataImageHandler, winrt::Microsoft::ReactNative::Composition::IUriImageProvider> {
   bool CanLoadImageUri(winrt::Microsoft::ReactNative::IReactContext context, winrt::Windows::Foundation::Uri uri) {
     return uri.SchemeName() == L"data";
   }
 
-  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> GetSourceAsync(
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
+  GetImageResponseAsync(
       const winrt::Microsoft::ReactNative::IReactContext &context,
       const winrt::Microsoft::ReactNative::Composition::ImageSource &imageSource) {
     auto path = winrt::to_string(imageSource.Uri().Path());
@@ -173,12 +179,57 @@ struct DataImageHandler : winrt::implements<
       co_await memoryStream.WriteAsync(buffer);
       memoryStream.Seek(0);
 
-      co_return memoryStream;
+      co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(memoryStream);
     } catch (winrt::hresult_error const &) {
       // Base64 decode failed
+      co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(
+          L"Invalid base64 encoding in inline image data");
     }
 
-    co_return nullptr;
+    winrt::throw_hresult(E_UNEXPECTED);
+  }
+};
+
+/**
+ * This ImageHandler will handle uri loading data from blobs
+ *
+ *   <Image
+ *      style={{width: 400, height: 200}}
+ *      source={{uri:'blob:<guid>?offset=<offset>&size=<size>'}}
+ *   />
+ *
+ */
+struct BlobImageHandler
+    : winrt::implements<BlobImageHandler, winrt::Microsoft::ReactNative::Composition::IUriImageProvider> {
+  bool CanLoadImageUri(winrt::Microsoft::ReactNative::IReactContext context, winrt::Windows::Foundation::Uri uri) {
+    return uri.SchemeName() == L"blob";
+  }
+
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
+  GetImageResponseAsync(
+      const winrt::Microsoft::ReactNative::IReactContext &context,
+      const winrt::Microsoft::ReactNative::Composition::ImageSource &imageSource) {
+    if (auto prop = winrt::Microsoft::ReactNative::ReactPropertyBag(context.Properties())
+                        .Get(::Microsoft::React::BlobModulePersistorPropertyId())) {
+      auto weakBlobPersistor = prop.Value();
+      if (auto persistor = weakBlobPersistor.lock()) {
+        auto queryParsed = imageSource.Uri().QueryParsed();
+        auto guid = winrt::to_string(imageSource.Uri().Path());
+        int64_t offset = _atoi64(winrt::to_string(queryParsed.GetFirstValueByName(L"offset")).c_str());
+        int64_t size = _atoi64(winrt::to_string(queryParsed.GetFirstValueByName(L"size")).c_str());
+
+        auto arr = persistor->ResolveMessage(std::move(guid), offset, size);
+        winrt::Windows::Storage::Streams::InMemoryRandomAccessStream memoryStream;
+        winrt::Windows::Storage::Streams::DataWriter dataWriter{memoryStream};
+        dataWriter.WriteBytes(arr);
+        co_await dataWriter.StoreAsync();
+        memoryStream.Seek(0);
+
+        co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(memoryStream.CloneStream());
+      }
+    }
+
+    co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(L"Failed to load image from blob");
   }
 };
 
@@ -191,6 +242,7 @@ static const ReactPropertyId<ReactNonAbiValue<std::shared_ptr<UriImageManager>>>
 UriImageManager::UriImageManager() {
   m_providers.push_back(winrt::make<SvgDataImageHandler>());
   m_providers.push_back(winrt::make<DataImageHandler>());
+  m_providers.push_back(winrt::make<BlobImageHandler>());
 }
 
 void UriImageManager::Install(
@@ -227,4 +279,17 @@ IUriImageProvider UriImageManager::TryGetUriImageProvider(
   return nullptr;
 }
 
+ImageResponseOrImageErrorInfo ImageResponse::ResolveImage() {
+  winrt::throw_hresult(E_NOTIMPL);
+}
+
+ImageResponseOrImageErrorInfo ImageFailedResponse::ResolveImage() {
+  ImageResponseOrImageErrorInfo imageOrError;
+  imageOrError.errorInfo = winrt::to_string(m_errorMessage);
+  if (imageOrError.errorInfo.empty()) {
+    imageOrError.errorInfo = "Failed to load image.";
+  }
+  return imageOrError;
+}
+
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

package/Microsoft.ReactNative/Fabric/Composition/UriImageManager.h

@@ -3,10 +3,16 @@
 
 #pragma once
 
+#include <Composition.Experimental.UriBrushFactoryImageResponse.g.h>
+#include <Composition.ImageFailedResponse.g.h>
+#include <Composition.ImageResponse.g.h>
+#include <Composition.StreamImageResponse.g.h>
+#include <Composition.UriBrushFactoryImageResponse.g.h>
 #include <ReactPropertyBag.h>
 #include <Utils/ImageUtils.h>
 #include <react/renderer/imagemanager/primitives.h>
 #include <winrt/Microsoft.ReactNative.Composition.h>
+#include "ImageResponseImage.h"
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
@@ -33,4 +39,77 @@ struct UriImageManager {
 winrt::Microsoft::ReactNative::Composition::ImageSource MakeImageSource(
     const facebook::react::ImageSource &source) noexcept;
 
+struct ImageResponseOrImageErrorInfo {
+  std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage> image;
+  std::string errorInfo;
+};
+
+struct ImageResponse : ImageResponseT<ImageResponse /*, IResolveImage*/> {
+  ImageResponse() noexcept = default;
+  virtual ImageResponseOrImageErrorInfo ResolveImage();
+};
+
+struct ImageFailedResponse : ImageFailedResponseT<ImageFailedResponse, ImageResponse /*, IResolveImage*/> {
+  ImageFailedResponse(winrt::hstring errorMessage) noexcept : base_type(), m_errorMessage(errorMessage) {}
+  ImageFailedResponse(
+      winrt::hstring errorMessage,
+      winrt::Windows::Web::Http::HttpStatusCode statusCode,
+      const winrt::Windows::Web::Http::Headers::HttpResponseHeaderCollection &responseHeaders) noexcept
+      : base_type(), m_errorMessage(errorMessage), m_statusCode(statusCode), m_responseHeaders(responseHeaders) {}
+
+  virtual ImageResponseOrImageErrorInfo ResolveImage();
+
+ private:
+  const winrt::hstring m_errorMessage;
+  const winrt::Windows::Web::Http::HttpStatusCode m_statusCode{winrt::Windows::Web::Http::HttpStatusCode::None};
+  const winrt::Windows::Web::Http::Headers::HttpResponseHeaderCollection m_responseHeaders{nullptr};
+};
+
+struct StreamImageResponse : StreamImageResponseT<StreamImageResponse, ImageResponse /*, IResolveImage*/> {
+  StreamImageResponse(const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept
+      : base_type(), m_stream(stream) {}
+  virtual ImageResponseOrImageErrorInfo ResolveImage();
+
+ private:
+  const winrt::Windows::Storage::Streams::IRandomAccessStream m_stream;
+};
+
+struct UriBrushFactoryImageResponse
+    : UriBrushFactoryImageResponseT<UriBrushFactoryImageResponse, ImageResponse /*, IResolveImage*/> {
+  UriBrushFactoryImageResponse(const winrt::Microsoft::ReactNative::Composition::UriBrushFactory &factory) noexcept
+      : base_type(), m_factory(factory) {}
+  virtual ImageResponseOrImageErrorInfo ResolveImage();
+
+ private:
+  const winrt::Microsoft::ReactNative::Composition::UriBrushFactory m_factory;
+};
+
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation
+
+namespace winrt::Microsoft::ReactNative::Composition::Experimental::implementation {
+struct UriBrushFactoryImageResponse
+    : UriBrushFactoryImageResponseT<
+          UriBrushFactoryImageResponse,
+          winrt::Microsoft::ReactNative::Composition::implementation::
+              ImageResponse /*, winrt::Microsoft::ReactNative::Composition::implementation::IResolveImage*/> {
+  UriBrushFactoryImageResponse(
+      const winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory &factory) noexcept
+      : base_type(), m_factory(factory) {}
+  virtual winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseOrImageErrorInfo ResolveImage();
+
+ private:
+  const winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory m_factory;
+};
+} // namespace winrt::Microsoft::ReactNative::Composition::Experimental::implementation
+
+namespace winrt::Microsoft::ReactNative::Composition::factory_implementation {
+struct ImageFailedResponse : ImageFailedResponseT<ImageFailedResponse, implementation::ImageFailedResponse> {};
+struct StreamImageResponse : StreamImageResponseT<StreamImageResponse, implementation::StreamImageResponse> {};
+struct UriBrushFactoryImageResponse
+    : UriBrushFactoryImageResponseT<UriBrushFactoryImageResponse, implementation::UriBrushFactoryImageResponse> {};
+} // namespace winrt::Microsoft::ReactNative::Composition::factory_implementation
+
+namespace winrt::Microsoft::ReactNative::Composition::Experimental::factory_implementation {
+struct UriBrushFactoryImageResponse
+    : UriBrushFactoryImageResponseT<UriBrushFactoryImageResponse, implementation::UriBrushFactoryImageResponse> {};
+} // namespace winrt::Microsoft::ReactNative::Composition::Experimental::factory_implementation

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -141,7 +141,7 @@ const IComponentViewRegistry &FabricUIManager::GetViewRegistry() const noexcept
 }
 
 void FabricUIManager::startSurface(
-    const winrt::Microsoft::ReactNative::CompositionRootView &rootView,
+    const winrt::Microsoft::ReactNative::ReactNativeIsland &rootView,
     facebook::react::SurfaceId surfaceId,
     const facebook::react::LayoutConstraints &layoutConstraints,
     const std::string &moduleName,
@@ -175,7 +175,7 @@ void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept
   m_surfaceManager->stopSurface(surfaceId);
 }
 
-winrt::Microsoft::ReactNative::CompositionRootView FabricUIManager::GetCompositionRootView(
+winrt::Microsoft::ReactNative::ReactNativeIsland FabricUIManager::GetReactNativeIsland(
     facebook::react::SurfaceId surfaceId) const noexcept {
   return m_surfaceRegistry.at(surfaceId).wkRootView.get();
 }

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -29,7 +29,7 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
   void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
   void startSurface(
-      const winrt::Microsoft::ReactNative::CompositionRootView &rootView,
+      const winrt::Microsoft::ReactNative::ReactNativeIsland &rootView,
       facebook::react::SurfaceId surfaceId,
       const facebook::react::LayoutConstraints &layoutConstraints,
       const std::string &moduleName,
@@ -49,7 +49,7 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
 
   const IComponentViewRegistry &GetViewRegistry() const noexcept;
 
-  winrt::Microsoft::ReactNative::CompositionRootView GetCompositionRootView(
+  winrt::Microsoft::ReactNative::ReactNativeIsland GetReactNativeIsland(
       facebook::react::SurfaceId surfaceId) const noexcept;
 
  private:
@@ -73,7 +73,7 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
 
   ComponentViewRegistry m_registry;
   struct SurfaceInfo {
-    winrt::weak_ref<winrt::Microsoft::ReactNative::CompositionRootView> wkRootView{nullptr};
+    winrt::weak_ref<winrt::Microsoft::ReactNative::ReactNativeIsland> wkRootView{nullptr};
   };
 
   std::unordered_map<facebook::react::SurfaceId, SurfaceInfo> m_surfaceRegistry;