react-native-windows 0.71.7 → 0.72.0-preview.1

package/Microsoft.ReactNative/Views/DevMenu.h

@@ -16,27 +16,15 @@ struct DevMenuManager : public std::enable_shared_from_this<DevMenuManager> {
   static void InitDevMenu(
       Mso::CntPtr<Mso::React::IReactContext> const &reactContext,
       Mso::VoidFunctor &&configureBundler) noexcept;
-  static void Show(React::IReactPropertyBag const &properties) noexcept;
-  static void Hide(React::IReactPropertyBag const &properties) noexcept;
+  static void Show(Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept;
 
  private:
-  void CreateAndShowUI() noexcept;
-  void Hide() noexcept;
   void Init() noexcept;
-
   const Mso::CntPtr<Mso::React::IReactContext> m_context;
-  xaml::Controls::Flyout m_flyout{nullptr};
-  xaml::Controls::Button::Click_revoker m_remoteDebugJSRevoker{};
-  xaml::Controls::Button::Click_revoker m_cancelRevoker{};
-  xaml::Controls::Button::Click_revoker m_toggleInspectorRevoker{};
-  xaml::Controls::Button::Click_revoker m_configBundlerRevoker{};
-  xaml::Controls::Button::Click_revoker m_reloadJSRevoker{};
-  xaml::Controls::Button::Click_revoker m_fastRefreshRevoker{};
-  xaml::Controls::Button::Click_revoker m_directDebuggingRevoker{};
-  xaml::Controls::Button::Click_revoker m_breakOnNextLineRevoker{};
+#ifndef CORE_ABI
   winrt::CoreDispatcher::AcceleratorKeyActivated_revoker m_coreDispatcherAKARevoker{};
   xaml::UIElement::KeyDown_revoker m_keyDownRevoker;
-  xaml::Controls::Button::Click_revoker m_samplingProfilerRevoker{};
+#endif
 };
 
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/FlyoutViewManager.cpp

@@ -17,6 +17,7 @@
 #include <UI.Xaml.Media.h>
 #include <Utils/Helpers.h>
 #include <Utils/PropertyHandlerUtils.h>
+#include <XamlHelper.h>
 
 #ifdef USE_WINUI3
 namespace winrt::Microsoft::UI::Xaml::Controls::Primitives {
@@ -122,7 +123,7 @@ class FlyoutShadowNode : public ShadowNodeBase {
   winrt::Popup GetFlyoutParentPopup() const;
   winrt::FlyoutPresenter GetFlyoutPresenter() const;
   void OnShowFlyout();
-  void LogErrorAndClose(const string &error);
+  void LogErrorAndClose(const std::string &error);
   xaml::FrameworkElement m_targetElement = nullptr;
   winrt::Flyout m_flyout = nullptr;
   bool m_isLightDismissEnabled = true;
@@ -192,12 +193,14 @@ void FlyoutShadowNode::createView(const winrt::Microsoft::ReactNative::JSValueOb
 
   m_flyoutClosedRevoker = m_flyout.Closed(winrt::auto_revoke, [=](auto &&, auto &&) {
     if (!m_updating) {
-      if (m_targetElement != nullptr) {
+      if (m_targetTag > 0) {
         // When the flyout closes, attempt to move focus to
         // its anchor element to prevent cases where focus can land on
         // an outer flyout content and therefore trigger a unexpected flyout
         // dismissal
-        xaml::Input::FocusManager::TryFocusAsync(m_targetElement, winrt::FocusState::Programmatic);
+        if (auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+          uiManager->focus(m_targetTag);
+        }
       }
 
       OnFlyoutClosed(GetViewManager()->GetReactContext(), m_tag, false);

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

@@ -89,10 +89,11 @@ class ImageShadowNode : public ShadowNodeBase {
         *reactImage, winrt::Microsoft::ReactNative::AccessibilityRoles::Image);
 
     m_onLoadEndToken = reactImage->OnLoadEnd([imageViewManager{static_cast<ImageViewManager *>(GetViewManager())},
-                                              reactImage](const auto &, const bool &succeeded) {
+                                              reactImage](const auto &, const winrt::hstring &error) {
       ReactImageSource source{reactImage->Source()};
 
-      imageViewManager->EmitImageEvent(reactImage.as<winrt::Grid>(), succeeded ? "topLoad" : "topError", source);
+      imageViewManager->EmitImageEvent(
+          reactImage.as<winrt::Grid>(), error.empty() ? "topLoad" : "topError", source, error);
       imageViewManager->EmitImageEvent(reactImage.as<winrt::Grid>(), "topLoadEnd", source);
     });
   }
@@ -166,12 +167,19 @@ bool ImageViewManager::UpdateProperty(
   return ret;
 }
 
-void ImageViewManager::EmitImageEvent(winrt::Grid grid, const char *eventName, ReactImageSource &source) {
+void ImageViewManager::EmitImageEvent(
+    winrt::Grid grid,
+    const char *eventName,
+    ReactImageSource &source,
+    const winrt::hstring &error) {
   int64_t tag = GetTag(grid);
   folly::dynamic imageSource =
       folly::dynamic::object()("uri", source.uri)("width", source.width)("height", source.height);
 
   folly::dynamic eventData = folly::dynamic::object()("target", tag)("source", imageSource);
+  if (!error.empty()) {
+    eventData["error"] = winrt::to_string(error);
+  }
   GetReactContext().DispatchEvent(tag, eventName, std::move(eventData));
 }
 

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

@@ -18,7 +18,11 @@ class ImageViewManager : public FrameworkElementViewManager {
       const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
   void GetNativeProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
   ShadowNode *createShadow() const override;
-  void EmitImageEvent(xaml::Controls::Grid grid, const char *eventName, ReactImageSource &source);
+  void EmitImageEvent(
+      xaml::Controls::Grid grid,
+      const char *eventName,
+      ReactImageSource &source,
+      const winrt::hstring &errorMessage = L"");
   void SetLayoutProps(
       ShadowNodeBase &nodeToUpdate,
       const XamlView &viewToUpdate,

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

@@ -12,7 +12,6 @@
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
 
-#include <Utils/ValueUtils.h>
 #include <Views/DynamicAutomationPeer.h>
 #include "Unicode.h"
 #include "XamlView.h"
@@ -64,7 +63,7 @@ winrt::Size ReactImage::ArrangeOverride(winrt::Size finalSize) {
   return finalSize;
 }
 
-winrt::event_token ReactImage::OnLoadEnd(winrt::EventHandler<bool> const &handler) {
+winrt::event_token ReactImage::OnLoadEnd(winrt::EventHandler<winrt::hstring> const &handler) {
   return m_onLoadEndEvent.add(handler);
 }
 
@@ -154,7 +153,7 @@ winrt::Stretch ReactImage::ResizeModeToStretch(winrt::Size size) {
 
 void ReactImage::Source(ReactImageSource source) {
   if (source.uri.length() == 0) {
-    m_onLoadEndEvent(*this, false);
+    m_onLoadEndEvent(*this, L"Empty URI");
     return;
   }
 
@@ -177,8 +176,8 @@ void ReactImage::Source(ReactImageSource source) {
     m_imageSource = source;
 
     SetBackground(true);
-  } catch (winrt::hresult_error const &) {
-    m_onLoadEndEvent(*this, false);
+  } catch (winrt::hresult_error const &err) {
+    m_onLoadEndEvent(*this, L"Failed to initialize ReactImage from source: " + err.message());
   }
 }
 
@@ -192,10 +191,12 @@ std::wstring GetUriFromImage(const winrt::Uri &uri) {
 }
 
 template <typename TImage>
-void ImageFailed(const TImage &image, const xaml::ExceptionRoutedEventArgs &args) {
+std::wstring ImageFailed(const TImage &image, const xaml::ExceptionRoutedEventArgs &args) {
+  std::wstring error{L"Failed to load image (" + args.ErrorMessage() + L")"};
 #ifdef DEBUG
-  cdebug << L"Failed to load image " << GetUriFromImage(image) << L" (" << args.ErrorMessage().c_str() << L")\n";
+  cdebug << error << L": " << GetUriFromImage(image) << L"\n";
 #endif
+  return error;
 }
 
 // TSourceFailedEventArgs can be either LoadedImageSourceLoadCompletedEventArgs or
@@ -203,14 +204,20 @@ void ImageFailed(const TImage &image, const xaml::ExceptionRoutedEventArgs &args
 // and the type of status are both enums with the same meaning
 // See LoadedImageSourceLoadStatus and SvgImageSourceLoadStatus.
 template <typename TImage, typename TSourceFailedEventArgs>
-void ImageFailed(const TImage &image, const TSourceFailedEventArgs &args) {
+std::wstring ImageFailed(const TImage &image, const TSourceFailedEventArgs &args) {
   // https://docs.microsoft.com/en-us/uwp/api/windows.ui.xaml.media.loadedimagesourceloadstatus
-#ifdef DEBUG
   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 << L"Failed to load image " << GetUriFromImage(image) << L" (" << statusNames[status] << L")\n";
+  cdebug << error.str() << L": " << GetUriFromImage(image) << L")\n";
 #endif
+  return error.str();
 }
 
 winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
@@ -235,15 +242,15 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
       // 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, false);
+          strong_this->m_onLoadEndEvent(*strong_this, L"Failed to get image memory stream");
         }
         co_return;
       }
     }
-  } catch (winrt::hresult_error const &) {
+  } catch (winrt::hresult_error const &err) {
     const auto strong_this{weak_this.get()};
     if (strong_this && fireLoadEndEvent) {
-      strong_this->m_onLoadEndEvent(*strong_this, false);
+      strong_this->m_onLoadEndEvent(*strong_this, L"Failed to set background: " + err.message());
     }
     co_return;
   }
@@ -280,7 +287,7 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
                 winrt::LoadedImageSurface const & /*sender*/,
                 winrt::LoadedImageSourceLoadCompletedEventArgs const &args) {
               if (auto strong_this{weak_this.get()}) {
-                bool succeeded{false};
+                std::wstring error;
                 if (args.Status() == winrt::LoadedImageSourceLoadStatus::Success) {
                   winrt::Size size{surface.DecodedPhysicalSize()};
                   strong_this->m_imageSource.height = size.Height;
@@ -301,13 +308,12 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
                   compositionBrush->TintColor(strong_this->m_tintColor);
 
                   strong_this->Background(compositionBrush.as<winrt::XamlCompositionBrushBase>());
-                  succeeded = true;
                 } else {
-                  ImageFailed(uri, args);
+                  error = ImageFailed(uri, args);
                 }
 
                 if (fireLoadEndEvent) {
-                  strong_this->m_onLoadEndEvent(*strong_this, succeeded);
+                  strong_this->m_onLoadEndEvent(*strong_this, error);
                 }
 
                 strong_this->m_sizeChangedRevoker.revoke();
@@ -329,15 +335,16 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
             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, true);
+                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, false);
+                strong_this->m_onLoadEndEvent(*strong_this, error);
               }
               ImageFailed(svgImageSource, args);
             });
@@ -385,7 +392,7 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
                     imageBrush.Stretch(strong_this->ResizeModeToStretch());
                   }
 
-                  strong_this->m_onLoadEndEvent(*strong_this, true);
+                  strong_this->m_onLoadEndEvent(*strong_this, L"");
                 }
               });
 
@@ -394,11 +401,11 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
               [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, false);
+                  strong_this->m_onLoadEndEvent(*strong_this, error);
                 }
-                ImageFailed(bitmapImage, args);
               });
 
           imageBrush.ImageSource(bitmapImage);

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

@@ -27,7 +27,7 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
   xaml::Automation::Peers::AutomationPeer OnCreateAutomationPeer();
 
   // Events
-  winrt::event_token OnLoadEnd(winrt::Windows::Foundation::EventHandler<bool> const &handler);
+  winrt::event_token OnLoadEnd(winrt::Windows::Foundation::EventHandler<winrt::hstring> const &handler);
   void OnLoadEnd(winrt::event_token const &token) noexcept;
 
   // Public Properties
@@ -65,7 +65,7 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
   facebook::react::ImageResizeMode m_resizeMode{facebook::react::ImageResizeMode::Contain};
   winrt::Windows::UI::Color m_tintColor{winrt::Colors::Transparent()};
 
-  winrt::event<winrt::Windows::Foundation::EventHandler<bool>> m_onLoadEndEvent;
+  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;