react-native-windows 0.81.1 → 0.82.0-preview.1

package/Microsoft.ReactNative/Views/Image/ReactImage.cpp

@@ -1,469 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-
-#include "ReactImage.h"
-
-#include <UI.Xaml.Media.Imaging.h>
-
-#include <winrt/Windows.Security.Cryptography.h>
-#include <winrt/Windows.Storage.Streams.h>
-#include <winrt/Windows.Web.Http.Headers.h>
-#include <winrt/Windows.Web.Http.h>
-
-#include <Networking/NetworkPropertyIds.h>
-#include <Views/DynamicAutomationPeer.h>
-#include "Unicode.h"
-#include "XamlView.h"
-#include "cdebug.h"
-
-namespace winrt {
-using namespace Windows::Foundation;
-using namespace Windows::Storage::Streams;
-using namespace Windows::UI;
-using namespace xaml;
-using namespace xaml::Media;
-using namespace xaml::Media::Imaging;
-using namespace Windows::Web::Http;
-using namespace xaml::Automation::Peers;
-} // namespace winrt
-
-using Microsoft::Common::Unicode::Utf8ToUtf16;
-
-namespace Microsoft::ReactNative {
-
-ReactImage::ReactImage(const Mso::React::IReactContext &context) : m_reactContext(&context) {}
-
-/*static*/ winrt::com_ptr<ReactImage> ReactImage::Create(const Mso::React::IReactContext &context) {
-  auto reactImage = winrt::make_self<ReactImage>(context);
-  // Grid inherits the layout direction from parent and mirrors the background image in RTL mode.
-  // Forcing the container to LTR mode to avoid the unexpected mirroring behavior.
-  reactImage->FlowDirection(xaml::FlowDirection::LeftToRight);
-  return reactImage;
-}
-
-winrt::Size ReactImage::ArrangeOverride(winrt::Size finalSize) {
-  if (m_useCompositionBrush) {
-    if (auto brush{Background().try_as<ReactImageBrush>()}) {
-      brush->AvailableSize(finalSize);
-    }
-  } else if (auto brush{Background().try_as<winrt::ImageBrush>()}) {
-    brush.Stretch(ResizeModeToStretch(finalSize));
-  }
-
-  if (m_imageSource.sourceFormat == ImageSourceFormat::Svg) {
-    if (auto const imageBrush{Background().try_as<winrt::ImageBrush>()}) {
-      if (auto const svgImageSource{imageBrush.ImageSource().try_as<winrt::SvgImageSource>()}) {
-        if (svgImageSource.RasterizePixelWidth() != GetWidth() ||
-            svgImageSource.RasterizePixelHeight() != GetHeight()) {
-          SetBackground(false);
-        }
-      }
-    }
-  }
-
-  return finalSize;
-}
-
-winrt::event_token ReactImage::OnLoadEnd(winrt::EventHandler<winrt::hstring> const &handler) {
-  return m_onLoadEndEvent.add(handler);
-}
-
-void ReactImage::OnLoadEnd(winrt::event_token const &token) noexcept {
-  m_onLoadEndEvent.remove(token);
-}
-
-winrt::AutomationPeer ReactImage::OnCreateAutomationPeer() {
-  return winrt::make<winrt::Microsoft::ReactNative::implementation::DynamicAutomationPeer>(*this);
-}
-
-void ReactImage::ResizeMode(facebook::react::ImageResizeMode value) {
-  if (m_resizeMode != value) {
-    m_resizeMode = value;
-
-    bool shouldUseCompositionBrush{
-        m_resizeMode == facebook::react::ImageResizeMode::Repeat || m_blurRadius > 0 || m_tintColor.A != 0};
-    bool switchBrushes{m_useCompositionBrush != shouldUseCompositionBrush};
-
-    if (switchBrushes) {
-      m_useCompositionBrush = shouldUseCompositionBrush;
-      SetBackground(false);
-    } else if (auto brush{Background().try_as<ReactImageBrush>()}) {
-      brush->ResizeMode(value);
-    } else if (auto bitmapBrush{Background().as<winrt::ImageBrush>()}) {
-      bitmapBrush.Stretch(ResizeModeToStretch());
-    }
-  }
-}
-
-void ReactImage::BlurRadius(float value) {
-  if (m_blurRadius != value) {
-    m_blurRadius = value;
-
-    bool shouldUseCompositionBrush{
-        m_resizeMode == facebook::react::ImageResizeMode::Repeat || m_blurRadius > 0 || m_tintColor.A != 0};
-    bool switchBrushes{m_useCompositionBrush != shouldUseCompositionBrush};
-
-    if (switchBrushes) {
-      m_useCompositionBrush = shouldUseCompositionBrush;
-      SetBackground(false);
-    } else if (auto brush{Background().try_as<ReactImageBrush>()}) {
-      brush->BlurRadius(value);
-    }
-  }
-}
-
-void ReactImage::TintColor(winrt::Color value) {
-  bool sameColor{
-      value.A == m_tintColor.A && value.R == m_tintColor.R && value.G == m_tintColor.G && value.B == m_tintColor.B};
-
-  if (!sameColor) {
-    m_tintColor = value;
-    bool shouldUseCompositionBrush{
-        m_resizeMode == facebook::react::ImageResizeMode::Repeat || m_blurRadius > 0 || m_tintColor.A != 0};
-    bool switchBrushes{m_useCompositionBrush != shouldUseCompositionBrush};
-
-    if (switchBrushes) {
-      m_useCompositionBrush = shouldUseCompositionBrush;
-      SetBackground(false);
-    } else if (auto brush{Background().try_as<ReactImageBrush>()}) {
-      brush->TintColor(value);
-    }
-  }
-}
-
-winrt::Stretch ReactImage::ResizeModeToStretch() {
-  return ResizeModeToStretch({static_cast<float>(ActualWidth()), static_cast<float>(ActualHeight())});
-}
-
-winrt::Stretch ReactImage::ResizeModeToStretch(winrt::Size size) {
-  switch (m_resizeMode) {
-    case facebook::react::ImageResizeMode::Cover:
-      return winrt::Stretch::UniformToFill;
-    case facebook::react::ImageResizeMode::Stretch:
-      return winrt::Stretch::Fill;
-    case facebook::react::ImageResizeMode::Contain:
-      return winrt::Stretch::Uniform;
-    default: // ResizeMode::Center || ResizeMode::Repeat
-      if (m_imageSource.height < size.Height && m_imageSource.width < size.Width) {
-        return winrt::Stretch::None;
-      } else {
-        return winrt::Stretch::Uniform;
-      }
-  }
-}
-
-void ReactImage::Source(ReactImageSource source) {
-  if (source.uri.length() == 0) {
-    m_onLoadEndEvent(*this, L"Empty URI");
-    return;
-  }
-
-  try {
-    winrt::Uri uri{UriTryCreate(Utf8ToUtf16(source.uri))};
-    winrt::hstring scheme{uri ? uri.SchemeName() : L""};
-    winrt::hstring ext{uri ? uri.Extension() : L""};
-
-    // Xaml default image handling can handle http/https uris.  However it will not use the specified headers in its
-    // request. If this image is using custom headers, or if we have a custom user-agent, then we have to download the
-    // image manually.
-    bool customUserAgent = !!winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties())
-                                 .Get(Microsoft::React::DefaultUserAgentPropertyId());
-    if (((scheme == L"http") || (scheme == L"https")) && (customUserAgent || !source.headers.empty())) {
-      source.sourceType = ImageSourceType::Download;
-    } else if (scheme == L"data") {
-      source.sourceType = ImageSourceType::InlineData;
-      if (source.uri.find("image/svg+xml;base64") != std::string::npos) {
-        source.sourceFormat = ImageSourceFormat::Svg;
-      }
-    } else if (ext == L".svg" || ext == L".svgz") {
-      source.sourceFormat = ImageSourceFormat::Svg;
-    }
-
-    m_imageSource = source;
-
-    SetBackground(true);
-  } catch (winrt::hresult_error const &err) {
-    m_onLoadEndEvent(*this, L"Failed to initialize ReactImage from source: " + err.message());
-  }
-}
-
-template <typename TImage>
-std::wstring GetUriFromImage(const TImage &image) {
-  return image.UriSource() ? image.UriSource().ToString().c_str() : L"<no Uri available>";
-}
-template <>
-std::wstring GetUriFromImage(const winrt::Uri &uri) {
-  return uri != nullptr ? uri.ToString().c_str() : L"<no Uri available>";
-}
-
-template <typename TImage>
-std::wstring ImageFailed(const TImage &image, const xaml::ExceptionRoutedEventArgs &args) {
-  std::wstring error{L"Failed to load image (" + args.ErrorMessage() + L")"};
-#ifdef DEBUG
-  cdebug << error << L": " << GetUriFromImage(image) << L"\n";
-#endif
-  return error;
-}
-
-// TSourceFailedEventArgs can be either LoadedImageSourceLoadCompletedEventArgs or
-// SvgImageSourceFailedEventArgs, because they both have Status() properties
-// and the type of status are both enums with the same meaning
-// See LoadedImageSourceLoadStatus and SvgImageSourceLoadStatus.
-template <typename TImage, typename TSourceFailedEventArgs>
-std::wstring ImageFailed(const TImage &image, const TSourceFailedEventArgs &args) {
-  // https://docs.microsoft.com/en-us/uwp/api/windows.ui.xaml.media.loadedimagesourceloadstatus
-  constexpr std::wstring_view statusNames[] = {L"Success", L"NetworkError", L"InvalidFormat", L"Other"};
-  const auto status = (int)args.Status();
-
-  std::wstringstream error{L"Failed to load image"};
-  if (0 <= status && status < ARRAYSIZE(statusNames)) {
-    error << L" (" << statusNames[status] << L")";
-  }
-#ifdef DEBUG
-  assert(0 <= status && status < ARRAYSIZE(statusNames));
-  cdebug << error.str() << L": " << GetUriFromImage(image) << L")\n";
-#endif
-  return error.str();
-}
-
-winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
-  const ReactImageSource source{m_imageSource};
-  winrt::Uri uri{UriTryCreate(Utf8ToUtf16(source.uri))};
-
-  // Increment the image source ID before any co_await calls
-  auto currentImageSourceId = ++m_imageSourceId;
-
-  const bool fromStream{
-      source.sourceType == ImageSourceType::Download || source.sourceType == ImageSourceType::InlineData};
-
-  winrt::IRandomAccessStream memoryStream{nullptr};
-
-  // get weak reference before any co_await calls
-  auto weak_this{get_weak()};
-
-  try {
-    if (fromStream) {
-      auto properties = m_reactContext->Properties();
-      memoryStream = co_await GetImageMemoryStreamAsync(properties, source);
-
-      // Fire failed load event if we're not loading from URI and the memory stream is null.
-      if (!memoryStream) {
-        if (auto strong_this{weak_this.get()}) {
-          strong_this->m_onLoadEndEvent(*strong_this, L"Failed to get image memory stream");
-        }
-        co_return;
-      }
-    }
-  } catch (winrt::hresult_error const &err) {
-    const auto strong_this{weak_this.get()};
-    if (strong_this && fireLoadEndEvent) {
-      strong_this->m_onLoadEndEvent(*strong_this, L"Failed to set background: " + err.message());
-    }
-    co_return;
-  }
-
-  if (auto strong_this{weak_this.get()}) {
-    // If the image source has been updated since this operation started, do not continue
-    if (currentImageSourceId != strong_this->m_imageSourceId) {
-      co_return;
-    }
-
-    if (strong_this->m_useCompositionBrush) {
-      const auto compositionBrush{ReactImageBrush::Create()};
-
-      compositionBrush->BlurRadius(strong_this->m_blurRadius);
-      compositionBrush->TintColor(strong_this->m_tintColor);
-
-      const auto surface = fromStream ? winrt::LoadedImageSurface::StartLoadFromStream(memoryStream)
-          : uri                       ? winrt::LoadedImageSurface::StartLoadFromUri(uri)
-                                      : nullptr;
-
-      m_sizeChangedRevoker = strong_this->SizeChanged(
-          winrt::auto_revoke, [compositionBrush](const auto &, const winrt::SizeChangedEventArgs &args) {
-            compositionBrush->AvailableSize(args.NewSize());
-          });
-
-      if (strong_this->m_surfaceLoadedRevoker) {
-        strong_this->m_surfaceLoadedRevoker.revoke();
-      }
-
-      if (surface) {
-        strong_this->m_surfaceLoadedRevoker = surface.LoadCompleted(
-            winrt::auto_revoke,
-            [weak_this, compositionBrush, surface, fireLoadEndEvent, uri](
-                winrt::LoadedImageSurface const & /*sender*/,
-                winrt::LoadedImageSourceLoadCompletedEventArgs const &args) {
-              if (auto strong_this{weak_this.get()}) {
-                std::wstring error;
-                if (args.Status() == winrt::LoadedImageSourceLoadStatus::Success) {
-                  winrt::Size size{surface.DecodedPhysicalSize()};
-                  strong_this->m_imageSource.height = size.Height;
-                  strong_this->m_imageSource.width = size.Width;
-
-                  // If we are dynamically switching the resizeMode to 'repeat', then
-                  // the SizeChanged event has already fired and the ReactImageBrush's
-                  // size has not been set. Use ActualWidth/Height in that case.
-                  if (compositionBrush->AvailableSize() == winrt::Size{0, 0}) {
-                    compositionBrush->AvailableSize(
-                        {static_cast<float>(strong_this->ActualWidth()),
-                         static_cast<float>(strong_this->ActualHeight())});
-                  }
-
-                  compositionBrush->Source(surface);
-                  compositionBrush->ResizeMode(strong_this->m_resizeMode);
-                  compositionBrush->BlurRadius(strong_this->m_blurRadius);
-                  compositionBrush->TintColor(strong_this->m_tintColor);
-
-                  strong_this->Background(compositionBrush.as<winrt::XamlCompositionBrushBase>());
-                } else {
-                  error = ImageFailed(uri, args);
-                }
-
-                if (fireLoadEndEvent) {
-                  strong_this->m_onLoadEndEvent(*strong_this, error);
-                }
-
-                strong_this->m_sizeChangedRevoker.revoke();
-              }
-            });
-      }
-    } else {
-      winrt::ImageBrush imageBrush{strong_this->Background().try_as<winrt::ImageBrush>()};
-      bool createImageBrush{!imageBrush};
-      if (createImageBrush) {
-        imageBrush = winrt::ImageBrush{};
-        imageBrush.Stretch(strong_this->ResizeModeToStretch());
-      }
-
-      if (source.sourceFormat == ImageSourceFormat::Svg) {
-        winrt::SvgImageSource svgImageSource{};
-
-        strong_this->m_svgImageSourceOpenedRevoker =
-            svgImageSource.Opened(winrt::auto_revoke, [weak_this, fireLoadEndEvent](const auto &, const auto &) {
-              auto strong_this{weak_this.get()};
-              if (strong_this && fireLoadEndEvent) {
-                strong_this->m_onLoadEndEvent(*strong_this, L"");
-              }
-            });
-
-        strong_this->m_svgImageSourceOpenFailedRevoker = svgImageSource.OpenFailed(
-            winrt::auto_revoke, [weak_this, fireLoadEndEvent, svgImageSource](const auto &, const auto &args) {
-              auto strong_this{weak_this.get()};
-              auto error = ImageFailed(svgImageSource, args);
-              if (strong_this && fireLoadEndEvent) {
-                strong_this->m_onLoadEndEvent(*strong_this, error);
-              }
-              ImageFailed(svgImageSource, args);
-            });
-
-        svgImageSource.RasterizePixelWidth(GetWidth());
-        svgImageSource.RasterizePixelHeight(GetHeight());
-
-        imageBrush.ImageSource(svgImageSource);
-
-        if (fromStream) {
-          try {
-            co_await svgImageSource.SetSourceAsync(memoryStream);
-          } catch (const winrt::hresult_error &) {
-            /*
-                winrt::hresult_canceled
-                If the app changes the image source again via SetSourceAsync, SetSource or UriSource while a
-               SetSourceAsync call is already in progress, the pending SetSourceAsync action will throw a
-               TaskCanceledException and set the Status to Canceled.
-
-                WINCODEC_ERR_BADIMAGE
-                In low memory situations (most likely on lower-memory phones), it is possible for an exception to be
-               raised with the message "The image is unrecognized" and an HRESULT of 0x88982F60. While this exception
-               ordinarily indicates bad data, if your app is close to its memory limit then the cause of the exception
-               is likely to be low memory. In that case, we recommend that you free memory and try again.
-            */
-          }
-        } else {
-          svgImageSource.UriSource(uri);
-        }
-      } else {
-        winrt::BitmapImage bitmapImage{imageBrush.ImageSource().try_as<winrt::BitmapImage>()};
-
-        if (!bitmapImage) {
-          bitmapImage = winrt::BitmapImage{};
-
-          strong_this->m_bitmapImageOpened = bitmapImage.ImageOpened(
-              winrt::auto_revoke, [imageBrush, weak_this, fireLoadEndEvent](const auto &, const auto &) {
-                imageBrush.Opacity(1);
-
-                auto strong_this{weak_this.get()};
-                if (strong_this && fireLoadEndEvent) {
-                  if (auto bitmap{imageBrush.ImageSource().try_as<winrt::BitmapImage>()}) {
-                    strong_this->m_imageSource.height = bitmap.PixelHeight();
-                    strong_this->m_imageSource.width = bitmap.PixelWidth();
-                    imageBrush.Stretch(strong_this->ResizeModeToStretch());
-                  }
-
-                  strong_this->m_onLoadEndEvent(*strong_this, L"");
-                }
-              });
-
-          strong_this->m_bitmapImageFailed = bitmapImage.ImageFailed(
-              winrt::auto_revoke,
-              [imageBrush, weak_this, fireLoadEndEvent, bitmapImage](const auto &, const auto &args) {
-                imageBrush.Opacity(1);
-
-                auto error = ImageFailed(bitmapImage, args);
-                auto strong_this{weak_this.get()};
-                if (strong_this && fireLoadEndEvent) {
-                  strong_this->m_onLoadEndEvent(*strong_this, error);
-                }
-              });
-
-          imageBrush.ImageSource(bitmapImage);
-        }
-
-        if (fromStream) {
-          try {
-            co_await bitmapImage.SetSourceAsync(memoryStream);
-          } catch (const winrt::hresult_error &) {
-            /*
-                winrt::hresult_canceled
-                If the app changes the image source again via SetSourceAsync, SetSource or UriSource while a
-               SetSourceAsync call is already in progress, the pending SetSourceAsync action will throw a
-               TaskCanceledException and set the Status to Canceled.
-
-                WINCODEC_ERR_BADIMAGE
-                In low memory situations (most likely on lower-memory phones), it is possible for an exception to be
-               raised with the message "The image is unrecognized" and an HRESULT of 0x88982F60. While this exception
-               ordinarily indicates bad data, if your app is close to its memory limit then the cause of the exception
-               is likely to be low memory. In that case, we recommend that you free memory and try again.
-            */
-          }
-        } else {
-          bitmapImage.UriSource(uri);
-
-          // It is possible that the same URI will be set twice if an intermediate update occurs that requires
-          // asynchronous behavior (e.g., when the ImageSourceType is ::Download or ::InlineData). In this case,
-          // do not set the opacity to zero as the ImageOpened event will not fire.
-          auto currentUri = bitmapImage.UriSource();
-          if (uri && currentUri && uri.AbsoluteUri() != currentUri.AbsoluteUri()) {
-            // TODO: When we change the source of a BitmapImage, we're getting a flicker of the old image
-            // being resized to the size of the new image. This is a temporary workaround.
-            imageBrush.Opacity(0);
-          }
-        }
-      }
-
-      if (createImageBrush) {
-        strong_this->Background(imageBrush);
-      }
-    }
-  }
-}
-
-double ReactImage::GetWidth() {
-  return std::isnan(Width()) ? m_imageSource.width : Width();
-}
-
-double ReactImage::GetHeight() {
-  return std::isnan(Height()) ? m_imageSource.height : Height();
-}
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/Image/ReactImage.h

@@ -1,80 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include "CppWinRTIncludes.h"
-#include "ReactImageBrush.h"
-
-#include <UI.Xaml.Controls.h>
-
-#include <JSValue.h>
-#include <React.h>
-#include <Utils/ImageUtils.h>
-#include <folly/dynamic.h>
-
-namespace Microsoft::ReactNative {
-
-struct ReactImage : xaml::Controls::GridT<ReactImage> {
-  using Super = xaml::Controls::GridT<ReactImage>;
-
-  ReactImage(const Mso::React::IReactContext &context);
-
- public:
-  static winrt::com_ptr<ReactImage> Create(const Mso::React::IReactContext &context);
-
-  // Overrides
-  winrt::Windows::Foundation::Size ArrangeOverride(winrt::Windows::Foundation::Size finalSize);
-  xaml::Automation::Peers::AutomationPeer OnCreateAutomationPeer();
-
-  // Events
-  winrt::event_token OnLoadEnd(winrt::Windows::Foundation::EventHandler<winrt::hstring> const &handler);
-  void OnLoadEnd(winrt::event_token const &token) noexcept;
-
-  // Public Properties
-  const ReactImageSource &Source() {
-    return m_imageSource;
-  }
-  void Source(ReactImageSource source);
-
-  facebook::react::ImageResizeMode ResizeMode() {
-    return m_resizeMode;
-  }
-  void ResizeMode(facebook::react::ImageResizeMode value);
-
-  float BlurRadius() {
-    return m_blurRadius;
-  }
-  void BlurRadius(float value);
-
-  winrt::Windows::UI::Color TintColor() {
-    return m_tintColor;
-  }
-  void TintColor(winrt::Windows::UI::Color value);
-
- private:
-  xaml::Media::Stretch ResizeModeToStretch();
-  xaml::Media::Stretch ResizeModeToStretch(winrt::Windows::Foundation::Size size);
-  winrt::fire_and_forget SetBackground(bool fireLoadEndEvent);
-  double GetWidth();
-  double GetHeight();
-
-  bool m_useCompositionBrush{false};
-  Mso::CntPtr<const Mso::React::IReactContext> m_reactContext;
-  float m_blurRadius{0};
-  int m_imageSourceId{0};
-  ReactImageSource m_imageSource;
-  facebook::react::ImageResizeMode m_resizeMode{facebook::react::ImageResizeMode::Contain};
-  winrt::Windows::UI::Color m_tintColor{winrt::Colors::Transparent()};
-
-  winrt::event<winrt::Windows::Foundation::EventHandler<winrt::hstring>> m_onLoadEndEvent;
-  xaml::FrameworkElement::SizeChanged_revoker m_sizeChangedRevoker;
-  xaml::Media::LoadedImageSurface::LoadCompleted_revoker m_surfaceLoadedRevoker;
-  xaml::Media::Imaging::BitmapImage::ImageOpened_revoker m_bitmapImageOpened;
-  xaml::Media::Imaging::BitmapImage::ImageFailed_revoker m_bitmapImageFailed;
-  xaml::Media::ImageBrush::ImageOpened_revoker m_imageBrushOpenedRevoker;
-  xaml::Media::Imaging::SvgImageSource::Opened_revoker m_svgImageSourceOpenedRevoker;
-  xaml::Media::Imaging::SvgImageSource::OpenFailed_revoker m_svgImageSourceOpenFailedRevoker;
-};
-
-} // namespace Microsoft::ReactNative