react-native-windows 0.74.7 → 0.74.8

package/Microsoft.ReactNative/Fabric/WindowsImageManager.cpp

@@ -5,84 +5,152 @@
 
 #include "WindowsImageManager.h"
 
+#include <CppRuntimeOptions.h>
 #include <Fabric/Composition/CompositionContextHelper.h>
 #include <Fabric/Composition/ImageResponseImage.h>
 #include <Fabric/Composition/UriImageManager.h>
+#include <Networking/NetworkPropertyIds.h>
 #include <Utils/ImageUtils.h>
+#include <fmt/format.h>
 #include <functional/functor.h>
 #include <shcore.h>
 #include <wincodec.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Windows.Web.Http.Headers.h>
+#include <winrt/Windows.Web.Http.h>
 
 extern "C" HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT SDKVersion, IWICImagingFactory **ppIWICImagingFactory);
 
 namespace Microsoft::ReactNative {
 
+std::string FormatHResultError(winrt::hresult_error const &ex) {
+  return fmt::format("[0x{:0>8x}] {}", static_cast<uint32_t>(ex.code()), winrt::to_string(ex.message()));
+}
+
 WindowsImageManager::WindowsImageManager(winrt::Microsoft::ReactNative::ReactContext reactContext)
     : m_reactContext(reactContext) {
   m_uriImageManager =
       winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager::Get(reactContext.Properties());
+
+  // Ideally we'd just set m_httpClient.DefaultRequestHeaders().UserAgent().ParseAdd(m_defaultUserAgent), but when we do
+  // we start hitting E_STATE_CHANGED errors. Which appears to be this issue
+  // https://github.com/MicrosoftDocs/winrt-api/issues/2410 So instead we apply the header to each request
+  auto userAgent = Microsoft::React::GetRuntimeOptionString("Http.UserAgent");
+  if (userAgent.size() > 0) {
+    m_defaultUserAgent = winrt::to_hstring(userAgent);
+  } else if (auto userAgentProp = reactContext.Properties().Get(::Microsoft::React::DefaultUserAgentPropertyId())) {
+    m_defaultUserAgent = *userAgentProp;
+  }
 }
 
-winrt::com_ptr<IWICBitmapSource> wicBitmapSourceFromStream(
-    const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept {
-  if (!results) {
-    return nullptr;
+std::tuple<winrt::com_ptr<IWICBitmapSource>, winrt::com_ptr<IWICImagingFactory>, std::string> wicBitmapSourceFromStream(
+    const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept {
+  try {
+    winrt::com_ptr<IWICImagingFactory> imagingFactory;
+    winrt::check_hresult(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, imagingFactory.put()));
+
+    winrt::com_ptr<IStream> istream;
+    winrt::check_hresult(
+        CreateStreamOverRandomAccessStream(stream.as<IUnknown>().get(), __uuidof(IStream), istream.put_void()));
+
+    winrt::com_ptr<IWICBitmapDecoder> bitmapDecoder;
+    winrt::check_hresult(imagingFactory->CreateDecoderFromStream(
+        istream.get(), nullptr, WICDecodeMetadataCacheOnDemand, bitmapDecoder.put()));
+
+    if (!bitmapDecoder) {
+      return {nullptr, nullptr, "Failed to decode the image."};
+    }
+
+    winrt::com_ptr<IWICBitmapFrameDecode> decodedFrame;
+    winrt::check_hresult(bitmapDecoder->GetFrame(0, decodedFrame.put()));
+    return {decodedFrame, imagingFactory, {}};
+  } catch (winrt::hresult_error const &ex) {
+    return {nullptr, nullptr, ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex))};
   }
+}
+
+winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
+WindowsImageManager::GetImageRandomAccessStreamAsync(ReactImageSource source) const {
+  co_await winrt::resume_background();
 
-  winrt::com_ptr<IWICImagingFactory> imagingFactory;
-  winrt::check_hresult(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, imagingFactory.put()));
+  winrt::Windows::Foundation::Uri uri(winrt::to_hstring(source.uri));
+  bool isFile = (uri.SchemeName() == L"file");
+  bool isAppx = (uri.SchemeName() == L"ms-appx");
 
-  winrt::com_ptr<IStream> istream;
-  winrt::check_hresult(
-      CreateStreamOverRandomAccessStream(results.as<IUnknown>().get(), __uuidof(IStream), istream.put_void()));
+  if (isFile || isAppx) {
+    winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::StorageFile> getFileSync{nullptr};
 
-  winrt::com_ptr<IWICBitmapDecoder> bitmapDecoder;
-  if (imagingFactory->CreateDecoderFromStream(
-          istream.get(), nullptr, WICDecodeMetadataCacheOnDemand, bitmapDecoder.put()) < 0) {
-    return nullptr;
+    if (isFile) {
+      getFileSync = winrt::Windows::Storage::StorageFile::GetFileFromPathAsync(uri.AbsoluteCanonicalUri());
+    } else {
+      getFileSync = winrt::Windows::Storage::StorageFile::GetFileFromApplicationUriAsync(uri);
+    }
+
+    winrt::Windows::Storage::StorageFile file(co_await getFileSync);
+    co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(co_await file.OpenReadAsync());
   }
 
-  winrt::com_ptr<IWICBitmapFrameDecode> decodedFrame;
-  winrt::check_hresult(bitmapDecoder->GetFrame(0, decodedFrame.put()));
-  return decodedFrame;
-}
+  auto httpMethod{
+      source.method.empty() ? winrt::Windows::Web::Http::HttpMethod::Get()
+                            : winrt::Windows::Web::Http::HttpMethod{winrt::to_hstring(source.method)}};
 
-std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage> generateBitmap(
-    const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept {
-  winrt::com_ptr<IWICBitmapSource> decodedFrame = wicBitmapSourceFromStream(results);
+  winrt::Windows::Web::Http::HttpRequestMessage request{httpMethod, uri};
 
-  if (!decodedFrame) {
-    return nullptr;
+  if (!m_defaultUserAgent.empty()) {
+    request.Headers().Append(L"User-Agent", m_defaultUserAgent);
+  }
+
+  if (!source.headers.empty()) {
+    for (auto &header : source.headers) {
+      if (_stricmp(header.first.c_str(), "authorization") == 0) {
+        request.Headers().TryAppendWithoutValidation(winrt::to_hstring(header.first), winrt::to_hstring(header.second));
+      } else {
+        request.Headers().Append(winrt::to_hstring(header.first), winrt::to_hstring(header.second));
+      }
+    }
   }
 
-  winrt::com_ptr<IWICImagingFactory> imagingFactory;
-  winrt::check_hresult(WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, imagingFactory.put()));
-  winrt::com_ptr<IWICFormatConverter> converter;
-  winrt::check_hresult(imagingFactory->CreateFormatConverter(converter.put()));
-
-  winrt::check_hresult(converter->Initialize(
-      decodedFrame.get(),
-      GUID_WICPixelFormat32bppPBGRA,
-      WICBitmapDitherTypeNone,
-      nullptr,
-      0.0f,
-      WICBitmapPaletteTypeMedianCut));
-
-  winrt::com_ptr<IWICBitmap> wicbmp;
-  winrt::check_hresult(imagingFactory->CreateBitmapFromSource(converter.get(), WICBitmapCacheOnLoad, wicbmp.put()));
-
-  auto image = std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
-  image->m_wicbmp = wicbmp;
-  return image;
+  winrt::Windows::Web::Http::HttpResponseMessage response(co_await m_httpClient.SendRequestAsync(request));
+
+  if (!response.IsSuccessStatusCode()) {
+    co_return winrt::Microsoft::ReactNative::Composition::ImageFailedResponse(
+        response.ReasonPhrase(), response.StatusCode(), response.Headers());
+  }
+
+  winrt::Windows::Storage::Streams::InMemoryRandomAccessStream memoryStream;
+  co_await response.Content().WriteToStreamAsync(memoryStream);
+  memoryStream.Seek(0);
+
+  co_return winrt::Microsoft::ReactNative::Composition::StreamImageResponse(memoryStream.CloneStream());
 }
 
-template <typename T>
-void ProcessImageRequestTask(
-    std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator> &weakObserverCoordinator,
-    const winrt::Windows::Foundation::IAsyncOperation<T> &task,
-    Mso::Functor<std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>(
-        const T &result)> &&onSuccess) {
-  task.Completed([weakObserverCoordinator, onSuccess = std::move(onSuccess)](auto asyncOp, auto status) {
+facebook::react::ImageRequest WindowsImageManager::requestImage(
+    const facebook::react::ImageSource &imageSource,
+    facebook::react::SurfaceId surfaceId) const {
+  auto imageRequest = facebook::react::ImageRequest(imageSource, nullptr, {});
+
+  auto weakObserverCoordinator = (std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator>)
+                                     imageRequest.getSharedObserverCoordinator();
+
+  auto rnImageSource = winrt::Microsoft::ReactNative::Composition::implementation::MakeImageSource(imageSource);
+  auto provider = m_uriImageManager->TryGetUriImageProvider(m_reactContext.Handle(), rnImageSource);
+
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
+      imageResponseTask{nullptr};
+
+  if (provider) {
+    imageResponseTask = provider.GetImageResponseAsync(m_reactContext.Handle(), rnImageSource);
+  } else {
+    ReactImageSource source;
+    source.uri = imageSource.uri;
+    source.height = imageSource.size.height;
+    source.width = imageSource.size.width;
+    source.sourceType = ImageSourceType::Download;
+
+    imageResponseTask = GetImageRandomAccessStreamAsync(source);
+  }
+
+  imageResponseTask.Completed([weakObserverCoordinator](auto asyncOp, auto status) {
     auto observerCoordinator = weakObserverCoordinator.lock();
     if (!observerCoordinator) {
       return;
@@ -90,12 +158,16 @@ void ProcessImageRequestTask(
 
     switch (status) {
       case winrt::Windows::Foundation::AsyncStatus::Completed: {
-        auto imageResponseImage = onSuccess(asyncOp.GetResults());
-        if (imageResponseImage)
+        auto imageResponse = asyncOp.GetResults();
+        auto selfImageResponse =
+            winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponse>(imageResponse);
+        auto imageResultOrError = selfImageResponse->ResolveImage();
+        if (imageResultOrError.image) {
           observerCoordinator->nativeImageResponseComplete(
-              facebook::react::ImageResponse(imageResponseImage, nullptr /*metadata*/));
-        else
+              facebook::react::ImageResponse(imageResultOrError.image, nullptr /*metadata*/));
+        } else {
           observerCoordinator->nativeImageResponseFailed();
+        }
         break;
       }
       case winrt::Windows::Foundation::AsyncStatus::Canceled: {
@@ -107,86 +179,86 @@ void ProcessImageRequestTask(
         break;
       }
       case winrt::Windows::Foundation::AsyncStatus::Started: {
+        // TODO progress? - Can we register for progress off the download task?
+        // observerCoordinator->nativeImageResponseProgress(0.0/*progress*/, 0/*completed*/, 0/*total*/);
+        break;
       }
     }
   });
+  return imageRequest;
 }
 
-facebook::react::ImageRequest WindowsImageManager::requestImage(
-    const facebook::react::ImageSource &imageSource,
-    facebook::react::SurfaceId surfaceId) const {
-  auto imageRequest = facebook::react::ImageRequest(imageSource, nullptr, {});
+} // namespace Microsoft::ReactNative
 
-  auto weakObserverCoordinator = (std::weak_ptr<const facebook::react::ImageResponseObserverCoordinator>)
-                                     imageRequest.getSharedObserverCoordinator();
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
-  auto rnImageSource = winrt::Microsoft::ReactNative::Composition::implementation::MakeImageSource(imageSource);
-  auto provider = m_uriImageManager->TryGetUriImageProvider(m_reactContext.Handle(), rnImageSource);
+ImageResponseOrImageErrorInfo StreamImageResponse::ResolveImage() {
+  ImageResponseOrImageErrorInfo imageOrError;
+  try {
+    auto result = ::Microsoft::ReactNative::wicBitmapSourceFromStream(m_stream);
 
-  if (auto bProvider = provider.try_as<winrt::Microsoft::ReactNative::Composition::IUriBrushProvider>()) {
-    ProcessImageRequestTask<winrt::Microsoft::ReactNative::Composition::UriBrushFactory>(
-        weakObserverCoordinator,
-        bProvider.GetSourceAsync(m_reactContext.Handle(), rnImageSource),
-        [](const winrt::Microsoft::ReactNative::Composition::UriBrushFactory &factory) noexcept {
-          auto image =
-              std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
-
-          // Wrap the UriBrushFactory to provide the internal CompositionContext types
-          image->m_brushFactory =
-              [factory](
-                  const winrt::Microsoft::ReactNative::IReactContext &context,
-                  const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext
-                      &compositionContext) {
-                auto compositor = winrt::Microsoft::ReactNative::Composition::Experimental::
-                    MicrosoftCompositionContextHelper::InnerCompositor(compositionContext);
-                auto brush = factory(context, compositor);
-                return winrt::Microsoft::ReactNative::Composition::Experimental::implementation::
-                    MicrosoftCompositionContextHelper::WrapBrush(brush);
-              };
-          return image;
-        });
-
-    return imageRequest;
+    auto &errorInfo = std::get<std::string>(result);
+    if (!errorInfo.empty()) {
+      imageOrError.errorInfo = errorInfo;
+      return imageOrError;
+    }
+
+    auto imagingFactory = std::get<winrt::com_ptr<IWICImagingFactory>>(result);
+    auto decodedFrame = std::get<winrt::com_ptr<IWICBitmapSource>>(result);
+
+    winrt::com_ptr<IWICFormatConverter> converter;
+    winrt::check_hresult(imagingFactory->CreateFormatConverter(converter.put()));
+
+    winrt::check_hresult(converter->Initialize(
+        decodedFrame.get(),
+        GUID_WICPixelFormat32bppPBGRA,
+        WICBitmapDitherTypeNone,
+        nullptr,
+        0.0f,
+        WICBitmapPaletteTypeMedianCut));
+
+    imageOrError.image =
+        std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
+    winrt::check_hresult(imagingFactory->CreateBitmapFromSource(
+        converter.get(), WICBitmapCacheOnLoad, imageOrError.image->m_wicbmp.put()));
+  } catch (winrt::hresult_error const &ex) {
+    imageOrError.errorInfo = ::Microsoft::ReactNative::FormatHResultError(winrt::hresult_error(ex));
   }
+  return imageOrError;
+}
 
-  if (auto brushProvider =
-          provider.try_as<winrt::Microsoft::ReactNative::Composition::Experimental::IUriBrushProvider>()) {
-    ProcessImageRequestTask<winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory>(
-        weakObserverCoordinator,
-        brushProvider.GetSourceAsync(m_reactContext.Handle(), rnImageSource),
-        [](const winrt::Microsoft::ReactNative::Composition::Experimental::UriBrushFactory &factory) noexcept {
-          auto image =
-              std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
-          image->m_brushFactory = factory;
-          return image;
-        });
-
-    return imageRequest;
+ImageResponseOrImageErrorInfo UriBrushFactoryImageResponse::ResolveImage() {
+  ImageResponseOrImageErrorInfo imageOrError;
+  imageOrError.image =
+      std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
+
+  // Wrap the UriBrushFactory to provide the internal CompositionContext types
+  imageOrError.image
+      ->m_brushFactory = [factory = m_factory](
+                             const winrt::Microsoft::ReactNative::IReactContext &context,
+                             const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext
+                                 &compositionContext) {
+    auto compositor =
+        winrt::Microsoft::ReactNative::Composition::Experimental::MicrosoftCompositionContextHelper::InnerCompositor(
+            compositionContext);
+    auto brush = factory(context, compositor);
+    return winrt::Microsoft::ReactNative::Composition::Experimental::implementation::MicrosoftCompositionContextHelper::
+        WrapBrush(brush);
   };
+  return imageOrError;
+}
 
-  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> task;
-  if (auto imageStreamProvider =
-          provider.try_as<winrt::Microsoft::ReactNative::Composition::IUriImageStreamProvider>()) {
-    task = imageStreamProvider.GetSourceAsync(m_reactContext.Handle(), rnImageSource);
-  } else {
-    ReactImageSource source;
-    source.uri = imageSource.uri;
-    source.height = imageSource.size.height;
-    source.width = imageSource.size.width;
-    source.sourceType = ImageSourceType::Download;
-
-    task = GetImageStreamAsync(source);
-  }
-
-  // TODO progress? - Can we register for progress off the download task?
-  // observerCoordinator->nativeImageResponseProgress((float)progress / (float)total);
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation
 
-  ProcessImageRequestTask<winrt::Windows::Storage::Streams::IRandomAccessStream>(
-      weakObserverCoordinator, task, [](const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) {
-        return generateBitmap(stream);
-      });
+namespace winrt::Microsoft::ReactNative::Composition::Experimental::implementation {
 
-  return imageRequest;
+winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseOrImageErrorInfo
+UriBrushFactoryImageResponse::ResolveImage() {
+  winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseOrImageErrorInfo imageOrError;
+  imageOrError.image =
+      std::make_shared<winrt::Microsoft::ReactNative::Composition::implementation::ImageResponseImage>();
+  imageOrError.image->m_brushFactory = m_factory;
+  return imageOrError;
 }
 
-} // namespace Microsoft::ReactNative
+} // namespace winrt::Microsoft::ReactNative::Composition::Experimental::implementation

package/Microsoft.ReactNative/Fabric/WindowsImageManager.h

@@ -7,6 +7,9 @@
 
 #include <Fabric/Composition/UriImageManager.h>
 #include <ReactContext.h>
+#include <Utils/ImageUtils.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Windows.Web.Http.h>
 
 namespace Microsoft::ReactNative {
 
@@ -18,8 +21,16 @@ struct WindowsImageManager {
       facebook::react::SurfaceId surfaceId) const;
 
  private:
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Microsoft::ReactNative::Composition::ImageResponse>
+  GetImageRandomAccessStreamAsync(ReactImageSource source) const;
+
+  winrt::Windows::Web::Http::HttpClient m_httpClient;
   winrt::Microsoft::ReactNative::ReactContext m_reactContext;
+  winrt::hstring m_defaultUserAgent;
   std::shared_ptr<winrt::Microsoft::ReactNative::Composition::implementation::UriImageManager> m_uriImageManager;
 };
 
+std::tuple<winrt::com_ptr<IWICBitmapSource>, winrt::com_ptr<IWICImagingFactory>, std::string> wicBitmapSourceFromStream(
+    const winrt::Windows::Storage::Streams::IRandomAccessStream &stream) noexcept;
+
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/HttpSettings.idl

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import "ReactInstanceSettings.idl";
+
+#include "DocString.h"
+
+namespace Microsoft.ReactNative
+{
+  [webhosthidden]
+  DOC_STRING(
+    "Provides settings for Http functionality. ")
+  runtimeclass HttpSettings
+  {
+    DOC_STRING(
+      "Configures the react instance to use a user-agent header by default on http requests.")
+    static void SetDefaultUserAgent(Microsoft.ReactNative.ReactInstanceSettings settings, String userAgent);
+  }
+} // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -14,6 +14,7 @@
 #include <Views/Image/ReactImage.h>
 #include <cxxreact/JsArgumentHelpers.h>
 #ifdef USE_FABRIC
+#include <Fabric/WindowsImageManager.h>
 #include <Utils/Helpers.h>
 #include <wincodec.h>
 #include "XamlUtils.h"
@@ -29,12 +30,8 @@ using namespace xaml::Media::Imaging;
 
 namespace Microsoft::ReactNative {
 
-#ifdef USE_FABRIC
-winrt::com_ptr<IWICBitmapSource> wicBitmapSourceFromStream(
-    const winrt::Windows::Storage::Streams::IRandomAccessStream &results) noexcept;
-#endif // USE_FABRIC
-
 winrt::fire_and_forget GetImageSizeAsync(
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &properties,
     std::string uriString,
     winrt::Microsoft::ReactNative::JSValue &&headers,
     Mso::Functor<void(int32_t width, int32_t height)> successCallback,
@@ -62,7 +59,7 @@ winrt::fire_and_forget GetImageSizeAsync(
 
     winrt::IRandomAccessStream memoryStream;
     if (needsDownload) {
-      memoryStream = co_await GetImageStreamAsync(source);
+      memoryStream = co_await GetImageStreamAsync(properties, source);
     } else if (inlineData) {
       memoryStream = co_await GetImageInlineDataAsync(source);
     }
@@ -80,11 +77,16 @@ winrt::fire_and_forget GetImageSizeAsync(
       }
 #ifdef USE_FABRIC
     } else {
-      UINT width, height;
-      auto wicBmpSource = wicBitmapSourceFromStream(memoryStream);
-      if (SUCCEEDED(wicBmpSource->GetSize(&width, &height))) {
-        successCallback(width, height);
-        succeeded = true;
+      auto result = wicBitmapSourceFromStream(memoryStream);
+      auto &errorInfo = std::get<std::string>(result);
+      if (errorInfo.empty()) {
+        auto imagingFactory = std::get<winrt::com_ptr<IWICImagingFactory>>(result);
+        auto wicBmpSource = std::get<winrt::com_ptr<IWICBitmapSource>>(result);
+        UINT width, height;
+        if (SUCCEEDED(wicBmpSource->GetSize(&width, &height))) {
+          successCallback(width, height);
+          succeeded = true;
+        }
       }
     }
 #endif // USE_FABRIC
@@ -105,6 +107,7 @@ void ImageLoader::getSize(std::string uri, React::ReactPromise<std::vector<doubl
   m_context.UIDispatcher().Post(
       [context = m_context, uri = std::move(uri), result = std::move(result)]() mutable noexcept {
         GetImageSizeAsync(
+            context.Properties().Handle(),
             std::move(uri),
             {},
             [result, context](double width, double height) noexcept {
@@ -133,6 +136,7 @@ void ImageLoader::getSizeWithHeaders(
                                  headers = std::move(headers),
                                  result = std::move(result)]() mutable noexcept {
     GetImageSizeAsync(
+        context.Properties().Handle(),
         std::move(uri),
         std::move(headers),
         [result, context](double width, double height) noexcept {

package/Microsoft.ReactNative/{CompositionRootView.idl → ReactNativeIsland.idl}

@@ -23,19 +23,19 @@ namespace Microsoft.ReactNative
   [default_interface]
   [webhosthidden]
   [experimental]
-  DOC_STRING("Argument type for @CompositionRootView.NavigateFocus.")
+  DOC_STRING("Argument type for @ReactNativeIsland.NavigateFocus.")
   runtimeclass FocusNavigationRequest {
     DOC_STRING("Creates new instance of @FocusNavigationRequest")
         FocusNavigationRequest(FocusNavigationReason reason);
 
-    DOC_STRING("The reason the @CompositionRootView is getting focus.")
+    DOC_STRING("The reason the @ReactNativeIsland is getting focus.")
     FocusNavigationReason Reason {get;set;};
   };
 
   [default_interface]
   [webhosthidden]
   [experimental]
-  DOC_STRING("Provides result from a @CompositionRootView.NavigateFocus method call.")
+  DOC_STRING("Provides result from a @ReactNativeIsland.NavigateFocus method call.")
   runtimeclass FocusNavigationResult {
     DOC_STRING("Gets a value that indicates whether the focus successfully moved.")
     Boolean WasFocusMoved {get;};
@@ -51,7 +51,7 @@ namespace Microsoft.ReactNative
   " in future versions")
   interface IInternalCompositionRootView
   {
-    DOC_STRING("The RootVisual associated with the @CompositionRootView. It must be set to show any React UI elements.")
+    DOC_STRING("The RootVisual associated with the @ReactNativeIsland. It must be set to show any React UI elements.")
     Microsoft.ReactNative.Composition.Experimental.IVisual InternalRootVisual { get; set; };
     
     DOC_STRING("Hosting Window that input is coming from. Only required when not using ContentIslands")
@@ -73,13 +73,13 @@ namespace Microsoft.ReactNative
   [webhosthidden]
   [experimental]
   DOC_STRING("A windows composition component that hosts React Native UI elements.")
-  runtimeclass CompositionRootView
+  runtimeclass ReactNativeIsland
   {
-    DOC_STRING("Creates a new instance of @CompositionRootView.")
-    CompositionRootView();
+    DOC_STRING("Creates a new instance of @ReactNativeIsland.")
+    ReactNativeIsland();
 
 #ifdef USE_WINUI3
-    CompositionRootView(Microsoft.UI.Composition.Compositor compositor);
+    ReactNativeIsland(Microsoft.UI.Composition.Compositor compositor);
 #endif
 
     DOC_STRING(
@@ -87,7 +87,7 @@ namespace Microsoft.ReactNative
       "It must be set to show any React UI elements.")
     IReactViewHost ReactViewHost { get; set; };
 
-    DOC_STRING("The RootVisual associated with the @CompositionRootView. It must be set to show any React UI elements.")
+    DOC_STRING("The RootVisual associated with the @ReactNativeIsland. It must be set to show any React UI elements.")
     Microsoft.UI.Composition.Visual RootVisual { get; };
 
     Windows.Foundation.Size Size { get; };
@@ -95,7 +95,7 @@ namespace Microsoft.ReactNative
     DOC_STRING("ScaleFactor for this windows (DPI/96)")
     Single ScaleFactor {get; set;};
 
-    DOC_STRING("Move focus to this @CompositionRootView")
+    DOC_STRING("Move focus to this @ReactNativeIsland")
     FocusNavigationResult NavigateFocus(FocusNavigationRequest request);
 
     Windows.Foundation.Size Measure(LayoutConstraints layoutConstraints, Windows.Foundation.Point viewportOffset);

package/Microsoft.ReactNative/UriImageManager.idl

@@ -20,27 +20,33 @@ namespace Microsoft.ReactNative.Composition
     Single Scale { get; };
   };
 
-
   [webhosthidden]
   [experimental]
-  interface IUriImageProvider
+  [default_interface]
+  unsealed runtimeclass ImageResponse
   {
-    DOC_STRING(
-      "This should return true if this provider will provide an image for the provided uri.")
-    Boolean CanLoadImageUri(Microsoft.ReactNative.IReactContext context, Windows.Foundation.Uri uri);
   }
 
   [webhosthidden]
   [experimental]
-    DOC_STRING(
-      "This allows applications to provide their own image caching / storage pipelines. Or to generate images on the fly based on uri.")
-  interface IUriImageStreamProvider requires IUriImageProvider
+  [default_interface]
+   DOC_STRING(
+    "Use this as a return value from @IUriImageProvider.GetImageResponseAsync to provide information about why the image load failed.")
+  runtimeclass ImageFailedResponse : ImageResponse
   {
-    DOC_STRING(
-      "Returns a stream of an image file that can be decoded by Windows Imaging Component - https://learn.microsoft.com/en-us/windows/win32/api/_wic/ ")
-    Windows.Foundation.IAsyncOperation<Windows.Storage.Streams.IRandomAccessStream> GetSourceAsync(Microsoft.ReactNative.IReactContext context, ImageSource imageSource);
+    ImageFailedResponse(String errorMessage);
+    ImageFailedResponse(String errorMessage, Windows.Web.Http.HttpStatusCode responseCode, Windows.Web.Http.Headers.HttpResponseHeaderCollection responseHeaders);
   }
 
+  [webhosthidden]
+  [experimental]
+  [default_interface]
+  runtimeclass StreamImageResponse : ImageResponse
+  {
+   DOC_STRING(
+    "Takes a stream of an image file that can be decoded by Windows Imaging Component - https://learn.microsoft.com/en-us/windows/win32/api/_wic/ ")
+    StreamImageResponse(Windows.Storage.Streams.IRandomAccessStream stream);
+  }
  
   [webhosthidden]
   [experimental]
@@ -48,13 +54,12 @@ namespace Microsoft.ReactNative.Composition
 
   [webhosthidden]
   [experimental]
+  [default_interface]
   DOC_STRING(
     "This allows applications to provide their own image rendering pipeline. Or to generate graphics on the fly based on uri.")
-  interface IUriBrushProvider requires IUriImageProvider
+  runtimeclass UriBrushFactoryImageResponse : ImageResponse
   {
-  DOC_STRING(
-    "This allows applications to provide their own image rendering pipeline. Or to generate graphics on the fly based on uri.")
-    Windows.Foundation.IAsyncOperation<UriBrushFactory> GetSourceAsync(Microsoft.ReactNative.IReactContext context, Microsoft.ReactNative.Composition.ImageSource imageSource);
+    UriBrushFactoryImageResponse(UriBrushFactory factory);
   }
 
   namespace Experimental {
@@ -65,11 +70,24 @@ namespace Microsoft.ReactNative.Composition
 
   [webhosthidden]
   [experimental]
+  [default_interface]
   DOC_STRING(
     "This allows applications to provide their own image rendering pipeline. Or to generate graphics on the fly based on uri.")
-  interface IUriBrushProvider requires Microsoft.ReactNative.Composition.IUriImageProvider
+  runtimeclass UriBrushFactoryImageResponse : Microsoft.ReactNative.Composition.ImageResponse
   {
-    Windows.Foundation.IAsyncOperation<UriBrushFactory> GetSourceAsync(Microsoft.ReactNative.IReactContext context, Microsoft.ReactNative.Composition.ImageSource imageSource);
+    UriBrushFactoryImageResponse(UriBrushFactory factory);
   }
+  } // namespace Experimental
+
+  [webhosthidden]
+  [experimental]
+    DOC_STRING(
+      "This allows applications to provide their own image caching / storage pipelines. Or to generate images on the fly based on uri.")
+  interface IUriImageProvider
+  {
+    DOC_STRING(
+      "This should return true if this provider will provide an image for the provided uri.")
+    Boolean CanLoadImageUri(Microsoft.ReactNative.IReactContext context, Windows.Foundation.Uri uri);
+    Windows.Foundation.IAsyncOperation<ImageResponse> GetImageResponseAsync(Microsoft.ReactNative.IReactContext context, ImageSource imageSource);
   }
 } // namespace Microsoft.ReactNative.Composition