react-native-windows 0.81.3 → 0.81.5

package/Microsoft.ReactNative/Modules/ImageViewManagerModule.cpp

@@ -30,20 +30,33 @@ using namespace xaml::Media::Imaging;
 
 namespace Microsoft::ReactNative {
 
+static const char *ERROR_INVALID_URI = "E_INVALID_URI";
+static const char *ERROR_GET_SIZE_FAILURE = "E_GET_SIZE_FAILURE";
+
 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,
-    Mso::Functor<void()> errorCallback
+    Mso::Functor<void(const char *errorCode, std::string errorMessage)> errorCallback
 #ifdef USE_FABRIC
     ,
     bool useFabric
 #endif // USE_FABRIC
 ) {
   bool succeeded{false};
+  const char *errorCode = ERROR_GET_SIZE_FAILURE;
+  std::string errorMessage;
 
   try {
+    // Validate URI is not empty
+    if (uriString.empty()) {
+      errorCode = ERROR_INVALID_URI;
+      errorMessage = "Cannot get the size of an image for an empty URI";
+      errorCallback(errorCode, errorMessage);
+      co_return;
+    }
+
     ReactImageSource source;
     source.uri = uriString;
     if (!headers.IsNull()) {
@@ -56,9 +69,10 @@ winrt::fire_and_forget GetImageSizeAsync(
     winrt::hstring scheme{uri.SchemeName()};
     bool needsDownload = (scheme == L"http") || (scheme == L"https");
     bool inlineData = scheme == L"data";
+    bool isLocalFile = (scheme == L"file") || (scheme == L"ms-appx") || (scheme == L"ms-appdata");
 
     winrt::IRandomAccessStream memoryStream;
-    if (needsDownload) {
+    if (needsDownload || isLocalFile) {
       memoryStream = co_await GetImageStreamAsync(properties, source);
     } else if (inlineData) {
       memoryStream = co_await GetImageInlineDataAsync(source);
@@ -77,23 +91,31 @@ winrt::fire_and_forget GetImageSizeAsync(
       }
 #ifdef USE_FABRIC
     } else {
-      auto result = wicBitmapSourceFromStream(memoryStream);
-      if (!std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
-        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;
+      if (memoryStream) { // Added nullcheck to prevent app from crashing if value is uninitialized
+        auto result = wicBitmapSourceFromStream(memoryStream);
+        if (!std::get<std::shared_ptr<facebook::react::ImageErrorInfo>>(result)) {
+          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
-  } catch (winrt::hresult_error const &) {
+  } catch (winrt::hresult_error const &e) {
+    errorMessage = "Failed to get image size: " + Microsoft::Common::Unicode::Utf16ToUtf8(std::wstring(e.message())) +
+        " for URI: " + uriString;
   }
 
-  if (!succeeded)
-    errorCallback();
+  if (!succeeded) {
+    if (errorMessage.empty()) {
+      errorMessage = "Failed to get image size for URI: " + uriString;
+    }
+    errorCallback(errorCode, errorMessage);
+  }
 
   co_return;
 }
@@ -112,7 +134,9 @@ void ImageLoader::getSize(std::string uri, React::ReactPromise<std::vector<doubl
             [result](double width, double height) noexcept {
               result.Resolve(std::vector<double>{width, height});
             },
-            [result]() noexcept { result.Reject("Failed"); }
+            [result](const char *errorCode, std::string errorMessage) noexcept {
+              result.Reject(React::ReactError{errorCode, errorMessage});
+            }
 #ifdef USE_FABRIC
             ,
             IsFabricEnabled(context.Properties().Handle())
@@ -137,7 +161,9 @@ void ImageLoader::getSizeWithHeaders(
         [result](double width, double height) noexcept {
           result.Resolve(Microsoft::ReactNativeSpecs::ImageLoaderIOSSpec_getSizeWithHeaders_returnType{width, height});
         },
-        [result]() noexcept { result.Reject("Failed"); }
+        [result](const char *errorCode, std::string errorMessage) noexcept {
+          result.Reject(React::ReactError{errorCode, errorMessage});
+        }
 #ifdef USE_FABRIC
         ,
         IsFabricEnabled(context.Properties().Handle())

package/Microsoft.ReactNative/Modules/LogBoxModule.cpp

@@ -12,6 +12,7 @@
 #ifdef USE_FABRIC
 #include <Fabric/Composition/CompositionContextHelper.h>
 #include <Fabric/Composition/CompositionUIService.h>
+#include <winrt/Microsoft.UI.Windowing.h>
 #include <winrt/Windows.UI.Composition.h>
 #else
 #include <UI.Xaml.Controls.Primitives.h>
@@ -22,16 +23,14 @@ namespace Microsoft::ReactNative {
 
 LogBox::~LogBox() {
 #ifdef USE_FABRIC
-  if (m_hwnd) {
-    m_context.UIDispatcher().Post([hwnd = m_hwnd]() { DestroyWindow(hwnd); });
-    m_hwnd = nullptr;
+  if (m_rnWindow) {
+    m_context.UIDispatcher().Post([rnWindow = m_rnWindow]() { rnWindow.Close(); });
+    m_rnWindow = nullptr;
   }
 #endif
 }
 
 #ifdef USE_FABRIC
-constexpr PCWSTR c_logBoxWindowClassName = L"MS_REACTNATIVE_LOGBOX";
-constexpr auto CompHostProperty = L"CompHost";
 const int LOGBOX_DEFAULT_WIDTH = 700;
 const int LOGBOX_DEFAULT_HEIGHT = 1000;
 #endif // USE_FABRIC
@@ -55,69 +54,6 @@ void LogBox::Hide() noexcept {
   });
 }
 
-#ifdef USE_FABRIC
-LRESULT CALLBACK LogBoxWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) noexcept {
-  auto data = reinterpret_cast<::IUnknown *>(GetProp(hwnd, CompHostProperty));
-  winrt::com_ptr<winrt::IUnknown> spunk;
-  React::CompositionHwndHost host{nullptr};
-
-  if (data) {
-    winrt::check_hresult(data->QueryInterface(winrt::guid_of<React::CompositionHwndHost>(), winrt::put_abi(host)));
-    auto result = static_cast<LRESULT>(host.TranslateMessage(message, wparam, lparam));
-    if (result)
-      return result;
-  }
-
-  switch (message) {
-    case WM_NCCREATE: {
-      auto cs = reinterpret_cast<CREATESTRUCT *>(lparam);
-      auto windowData = static_cast<::IUnknown *>(cs->lpCreateParams);
-      SetProp(hwnd, CompHostProperty, reinterpret_cast<::IUnknown *>(windowData));
-      break;
-    }
-    case WM_CREATE: {
-      host.Initialize((uint64_t)hwnd);
-      break;
-    }
-    case WM_CLOSE: {
-      // Just hide the window instead of destroying it
-      ::ShowWindow(hwnd, SW_HIDE);
-      return 0;
-    }
-    case WM_DESTROY: {
-      data->Release();
-      SetProp(hwnd, CompHostProperty, nullptr);
-    }
-  }
-
-  return DefWindowProc(hwnd, message, wparam, lparam);
-}
-
-void LogBox::RegisterWndClass() noexcept {
-  static bool registered = false;
-  if (registered)
-    return;
-
-  HINSTANCE hInstance = GetModuleHandle(NULL);
-
-  WNDCLASSEXW wcex = {};
-  wcex.cbSize = sizeof(WNDCLASSEX);
-  wcex.style = CS_HREDRAW | CS_VREDRAW;
-  wcex.lpfnWndProc = &LogBoxWndProc;
-  wcex.cbClsExtra = DLGWINDOWEXTRA;
-  wcex.cbWndExtra = sizeof(winrt::impl::abi<winrt::Microsoft::ReactNative::ICompositionHwndHost>::type *);
-  wcex.hInstance = hInstance;
-  wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
-  wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
-  wcex.lpszClassName = c_logBoxWindowClassName;
-  ATOM classId = RegisterClassEx(&wcex);
-  WINRT_VERIFY(classId);
-  winrt::check_win32(!classId);
-
-  registered = true;
-}
-#endif // USE_FABRIC
-
 void LogBox::ShowOnUIThread() noexcept {
   auto host = React::implementation::ReactNativeHost::GetReactNativeHost(m_context.Properties());
   if (!host)
@@ -173,45 +109,34 @@ void LogBox::ShowOnUIThread() noexcept {
   }
 #else
   else {
-    RegisterWndClass();
-
-    if (!m_hwnd) {
+    if (!m_rnWindow) {
+      m_rnWindow = winrt::Microsoft::ReactNative::ReactNativeWindow::CreateFromCompositor(
+          winrt::Microsoft::ReactNative::Composition::CompositionUIService::GetCompositor(
+              host.InstanceSettings().Properties()));
       auto CompositionHwndHost = React::CompositionHwndHost();
       winrt::Microsoft::ReactNative::ReactViewOptions viewOptions;
       viewOptions.ComponentName(L"LogBox");
-      CompositionHwndHost.ReactViewHost(
+      m_rnWindow.AppWindow().Title(L"LogBox");
+      m_rnWindow.AppWindow().Closing([](winrt::Microsoft::UI::Windowing::AppWindow const & /*appWindow*/,
+                                        winrt::Microsoft::UI::Windowing::AppWindowClosingEventArgs const &args) {
+        // Prevent default close behavior - as JS will never try to show the logbox again if it isn't hidden through JS
+        args.Cancel(true);
+      });
+      m_rnWindow.ReactNativeIsland().ReactViewHost(
           winrt::Microsoft::ReactNative::ReactCoreInjection::MakeViewHost(host, viewOptions));
-      HINSTANCE hInstance = GetModuleHandle(NULL);
-      winrt::impl::abi<winrt::Microsoft::ReactNative::ICompositionHwndHost>::type *pHost{nullptr};
-      winrt::com_ptr<::IUnknown> spunk;
-      CompositionHwndHost.as(spunk);
-      spunk->AddRef(); // Will be stored in windowData
-
-      m_hwnd = CreateWindow(
-          c_logBoxWindowClassName,
-          L"React-Native LogBox",
-          WS_OVERLAPPEDWINDOW,
-          CW_USEDEFAULT,
-          CW_USEDEFAULT,
-          LOGBOX_DEFAULT_WIDTH,
-          LOGBOX_DEFAULT_HEIGHT,
-          nullptr,
-          nullptr,
-          hInstance,
-          spunk.get());
+      m_rnWindow.AppWindow().ResizeClient({LOGBOX_DEFAULT_WIDTH, LOGBOX_DEFAULT_HEIGHT});
     }
 
-    ShowWindow(m_hwnd, SW_NORMAL);
-    BringWindowToTop(m_hwnd);
-    SetFocus(m_hwnd);
+    m_rnWindow.AppWindow().Show(true);
+    m_rnWindow.AppWindow().MoveInZOrderAtTop();
   }
 #endif // USE_FABRIC
 }
 
 void LogBox::HideOnUIThread() noexcept {
 #ifdef USE_FABRIC
-  if (m_hwnd) {
-    ::ShowWindow(m_hwnd, SW_HIDE);
+  if (m_rnWindow) {
+    m_rnWindow.AppWindow().Hide();
   }
 #else // USE_FABRIC
   if (m_popup) {

package/Microsoft.ReactNative/Modules/LogBoxModule.h

@@ -31,7 +31,7 @@ struct LogBox : public std::enable_shared_from_this<LogBox> {
 
   winrt::Microsoft::ReactNative::ReactContext m_context;
 #ifdef USE_FABRIC
-  HWND m_hwnd{nullptr};
+  winrt::Microsoft::ReactNative::ReactNativeWindow m_rnWindow{nullptr};
 #else
   xaml::Controls::Primitives::Popup m_popup{nullptr};
   winrt::Microsoft::ReactNative::ReactRootView m_logBoxContent{nullptr};

package/Microsoft.ReactNative/ReactNativeAppBuilder.cpp

@@ -20,19 +20,6 @@ ReactNativeAppBuilder::ReactNativeAppBuilder() {
 
 ReactNativeAppBuilder::~ReactNativeAppBuilder() {}
 
-winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetDispatcherQueueController(
-    winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController) {
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
-      dispatcherQueueController);
-  return *this;
-}
-
-winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetCompositor(
-    winrt::Microsoft::UI::Composition::Compositor const &compositor) {
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
-  return *this;
-}
-
 winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetAppWindow(
     winrt::Microsoft::UI::Windowing::AppWindow const &appWindow) {
   m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
@@ -41,34 +28,6 @@ winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetA
 }
 
 winrt::Microsoft::ReactNative::ReactNativeWin32App ReactNativeAppBuilder::Build() {
-  // Create the DispatcherQueueController if the app developer doesn't provide one
-  if (m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController() == nullptr) {
-    assert(m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor() == nullptr);
-
-    // Create a DispatcherQueue for this thread. This is needed for Composition, Content, and Input APIs.
-    auto dispatcherQueueController =
-        winrt::Microsoft::UI::Dispatching::DispatcherQueueController::CreateOnCurrentThread();
-
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
-        dispatcherQueueController);
-  }
-
-  // Create the Compositor if the app developer doesn't provide one
-  if (m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor() == nullptr) {
-    // Create the compositor on behalf of the App Developer.
-    auto compositor = winrt::Microsoft::UI::Composition::Compositor();
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
-  }
-
-  // Create the AppWindow if the app developer doesn't provide one
-  if (m_reactNativeWin32App.AppWindow() == nullptr) {
-    auto appWindow = winrt::Microsoft::UI::Windowing::AppWindow::Create();
-    appWindow.Title(L"ReactNativeWin32App");
-    appWindow.Resize({1000, 1000});
-
-    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
-  }
-
   return m_reactNativeWin32App;
 }
 

package/Microsoft.ReactNative/ReactNativeAppBuilder.idl

@@ -18,12 +18,6 @@ namespace Microsoft.ReactNative {
 
         ReactViewOptions ReactViewOptions {get;};
 
-        // TODO: Hide these APIs for now until we're sure we need to expose them and can do so safely
-        // Microsoft.UI.Composition.Compositor Compositor {get;};
-        // Microsoft.UI.Content.DesktopChildSiteBridge DesktopChildSiteBridge {get;};
-        // Microsoft.UI.Dispatching DispatcherQueueController {get;};
-        // ReactNativeIsland ReactNativeIsland {get;};
-
         // Methods
         void Start();
      }
@@ -38,11 +32,6 @@ namespace Microsoft.ReactNative {
 
         ReactNativeAppBuilder SetAppWindow(Microsoft.UI.Windowing.AppWindow appWindow);
 
-        // TODO: Hide these APIs for now until we're sure we need to expose them and can do so safely
-        // Compositor depends on the DispatcherQueue created by DispatcherQueueController
-        // ReactNativeAppBuilder SetCompositor(Microsoft.UI.Composition.Compositor compositor);
-        // ReactNativeAppBuilder SetDispatcherQueueController(Microsoft.UI.Dispatching DispatcherQueueController);
-
         ReactNativeWin32App Build();
     }
 }

package/Microsoft.ReactNative/ReactNativeIsland.idl

@@ -80,9 +80,6 @@ namespace Microsoft.ReactNative
   DOC_STRING("A windows composition component that hosts React Native UI elements.")
   runtimeclass ReactNativeIsland
   {
-    DOC_STRING("Creates a new instance of @ReactNativeIsland. Can be implemented with a ReactViewHost or a ComponentView with reactContext")
-    ReactNativeIsland();
-
 #ifdef USE_WINUI3
     ReactNativeIsland(Microsoft.UI.Composition.Compositor compositor);
 
@@ -100,6 +97,8 @@ namespace Microsoft.ReactNative
 
     Windows.Foundation.Size Size { get; };
 
+    Microsoft.UI.Composition.Compositor Compositor { get; };
+
     DOC_STRING("ScaleFactor for this windows (DPI/96)")
     Single ScaleFactor {get; set;};
   

package/Microsoft.ReactNative/ReactNativeWin32App.cpp

@@ -15,34 +15,10 @@
 #include "winrt/Microsoft.UI.Interop.h"
 #include "winrt/Microsoft.UI.Windowing.h"
 
-// Scaling factor for the window's content based on the DPI of the display where the window is located.
-float ScaleFactor(HWND hwnd) noexcept {
-  return GetDpiForWindow(hwnd) / static_cast<float>(USER_DEFAULT_SCREEN_DPI);
-}
-
-void UpdateRootViewSizeToAppWindow(
-    winrt::Microsoft::ReactNative::ReactNativeIsland const &rootView,
-    winrt::Microsoft::UI::Windowing::AppWindow const &window) {
-  auto hwnd = winrt::Microsoft::UI::GetWindowFromWindowId(window.Id());
-  auto scaleFactor = ScaleFactor(hwnd);
-  winrt::Windows::Foundation::Size size{
-      window.ClientSize().Width / scaleFactor, window.ClientSize().Height / scaleFactor};
-  // Do not relayout when minimized
-  if (window.Presenter().as<winrt::Microsoft::UI::Windowing::OverlappedPresenter>().State() !=
-      winrt::Microsoft::UI::Windowing::OverlappedPresenterState::Minimized) {
-    winrt::Microsoft::ReactNative::LayoutConstraints constraints;
-    constraints.LayoutDirection = winrt::Microsoft::ReactNative::LayoutDirection::Undefined;
-    constraints.MaximumSize = constraints.MinimumSize = size;
-    rootView.Arrange(constraints, {0, 0});
-  }
-}
-
 namespace winrt::Microsoft::ReactNative::implementation {
 ReactNativeWin32App::ReactNativeWin32App() {}
 
 ReactNativeWin32App::~ReactNativeWin32App() {
-  m_desktopChildSiteBridge = nullptr;
-
   // Destroy all Composition objects
   if (m_compositor != nullptr) {
     m_compositor.Close();
@@ -51,7 +27,7 @@ ReactNativeWin32App::~ReactNativeWin32App() {
 }
 
 winrt::Microsoft::UI::Windowing::AppWindow ReactNativeWin32App::AppWindow() {
-  return m_appWindow;
+  return ReactNativeWindow().AppWindow();
 }
 
 void ReactNativeWin32App::AppWindow(winrt::Microsoft::UI::Windowing::AppWindow const &appWindow) {
@@ -59,29 +35,19 @@ void ReactNativeWin32App::AppWindow(winrt::Microsoft::UI::Windowing::AppWindow c
 }
 
 winrt::Microsoft::UI::Composition::Compositor ReactNativeWin32App::Compositor() {
-  return m_compositor;
-}
-
-void ReactNativeWin32App::Compositor(winrt::Microsoft::UI::Composition::Compositor const &compositor) {
-  m_compositor = compositor;
-}
-
-void ReactNativeWin32App::DesktopChildSiteBridge(
-    winrt::Microsoft::UI::Content::DesktopChildSiteBridge const &desktopChildSiteBridge) {
-  m_desktopChildSiteBridge = desktopChildSiteBridge;
-}
-
-winrt::Microsoft::UI::Content::DesktopChildSiteBridge ReactNativeWin32App::DesktopChildSiteBridge() {
-  return m_desktopChildSiteBridge;
-}
+  if (m_compositor == nullptr) {
+    // Create a DispatcherQueue for this thread. This is needed for Composition, Content, and Input APIs.
+    m_dispatcherQueueController = winrt::Microsoft::UI::Dispatching::DispatcherQueueController::CreateOnCurrentThread();
 
-winrt::Microsoft::UI::Dispatching::DispatcherQueueController ReactNativeWin32App::DispatcherQueueController() {
-  return m_dispatcherQueueController;
-}
+    // Currently set the property to use current thread dispatcher as a default UI dispatcher.
+    ReactNativeHost().InstanceSettings().Properties().Set(
+        ReactDispatcherHelper::UIDispatcherProperty(), ReactDispatcherHelper::UIThreadDispatcher());
 
-void ReactNativeWin32App::DispatcherQueueController(
-    winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController) {
-  m_dispatcherQueueController = dispatcherQueueController;
+    m_compositor = winrt::Microsoft::UI::Composition::Compositor();
+    winrt::Microsoft::ReactNative::Composition::CompositionUIService::SetCompositor(
+        ReactNativeHost().InstanceSettings(), m_compositor);
+  }
+  return m_compositor;
 }
 
 winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeWin32App::ReactNativeHost() {
@@ -91,18 +57,6 @@ winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeWin32App::ReactNativeH
   return m_host;
 }
 
-void ReactNativeWin32App::ReactNativeHost(winrt::Microsoft::ReactNative::ReactNativeHost const &host) {
-  m_host = host;
-}
-
-winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeWin32App::ReactNativeIsland() {
-  return m_reactNativeIsland;
-}
-
-void ReactNativeWin32App::ReactNativeIsland(winrt::Microsoft::ReactNative::ReactNativeIsland const &reactNativeIsland) {
-  m_reactNativeIsland = reactNativeIsland;
-}
-
 winrt::Microsoft::ReactNative::ReactViewOptions ReactNativeWin32App::ReactViewOptions() {
   if (m_reactViewOptions == nullptr) {
     m_reactViewOptions = winrt::make<winrt::Microsoft::ReactNative::implementation::ReactViewOptions>();
@@ -114,45 +68,36 @@ void ReactNativeWin32App::ReactViewOptions(winrt::Microsoft::ReactNative::ReactV
   m_reactViewOptions = viewOptions;
 }
 
+winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWin32App::ReactNativeWindow() noexcept {
+  if (!m_rnWindow) {
+    if (m_appWindow) {
+      m_rnWindow = winrt::Microsoft::ReactNative::ReactNativeWindow::CreateFromWindow(m_appWindow, Compositor());
+    } else {
+      m_rnWindow = winrt::Microsoft::ReactNative::ReactNativeWindow::CreateFromCompositor(Compositor());
+      m_appWindow = m_rnWindow.AppWindow();
+      m_appWindow.Title(L"ReactNativeWin32App");
+      m_appWindow.Resize({1000, 1000});
+    }
+  }
+
+  return m_rnWindow;
+}
+
 void ReactNativeWin32App::Start() {
   // Show the hosting AppWindow
-  m_appWindow.Show();
-
-  // Currently set the property to use current thread dispatcher as a default UI dispatcher.
-  // TODO: Use the correct dispatcher from a developer-provided DispatcherQueueController
-  ReactNativeHost().InstanceSettings().Properties().Set(
-      ReactDispatcherHelper::UIDispatcherProperty(), ReactDispatcherHelper::UIThreadDispatcher());
+  AppWindow().Show();
 
   auto hwnd{winrt::Microsoft::UI::GetWindowFromWindowId(m_appWindow.Id())};
 
   winrt::Microsoft::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
       ReactNativeHost().InstanceSettings().Properties(), reinterpret_cast<uint64_t>(hwnd));
 
-  winrt::Microsoft::ReactNative::Composition::CompositionUIService::SetCompositor(
-      ReactNativeHost().InstanceSettings(), m_compositor);
-
   // Start the react-native instance, which will create a JavaScript runtime and load the applications bundle.
   ReactNativeHost().ReloadInstance();
 
-  // Create a RootView which will present a react-native component
-  if (m_reactNativeIsland == nullptr) {
-    m_reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland(m_compositor);
-  }
-
-  m_reactNativeIsland.ReactViewHost(
+  m_rnWindow.ReactNativeIsland().ReactViewHost(
       winrt::Microsoft::ReactNative::ReactCoreInjection::MakeViewHost(ReactNativeHost(), ReactViewOptions()));
 
-  // Update the size of the RootView when the AppWindow changes size
-  m_appWindow.Changed([wkRootView = winrt::make_weak(m_reactNativeIsland)](
-                          winrt::Microsoft::UI::Windowing::AppWindow const &window,
-                          winrt::Microsoft::UI::Windowing::AppWindowChangedEventArgs const &args) {
-    if (args.DidSizeChange() || args.DidVisibilityChange()) {
-      if (auto rootView = wkRootView.get()) {
-        UpdateRootViewSizeToAppWindow(rootView, window);
-      }
-    }
-  });
-
   // Quit application when main window is closed
   m_appWindow.Destroying([this](
                              winrt::Microsoft::UI::Windowing::AppWindow const &window,
@@ -166,28 +111,13 @@ void ReactNativeWin32App::Start() {
     });
   });
 
-  // DesktopChildSiteBridge create a ContentSite that can host the RootView ContentIsland
-  m_desktopChildSiteBridge =
-      winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(m_compositor, m_appWindow.Id());
-
-  m_desktopChildSiteBridge.Connect(m_reactNativeIsland.Island());
-
-  m_desktopChildSiteBridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
-
-  auto scaleFactor = ScaleFactor(hwnd);
-  m_reactNativeIsland.ScaleFactor(scaleFactor);
-
-  UpdateRootViewSizeToAppWindow(m_reactNativeIsland, m_appWindow);
-
-  m_desktopChildSiteBridge.Show();
-
   // Run the main application event loop
   m_dispatcherQueueController.DispatcherQueue().RunEventLoop();
 
+  m_appWindow.Destroy();
+
   // Rundown the DispatcherQueue. This drains the queue and raises events to let components
   // know the message loop has finished.
   m_dispatcherQueueController.ShutdownQueue();
-
-  m_desktopChildSiteBridge.Close();
 }
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactNativeWin32App.h

@@ -15,20 +15,10 @@ struct ReactNativeWin32App : ReactNativeWin32AppT<ReactNativeWin32App> {
   winrt::Microsoft::UI::Windowing::AppWindow AppWindow();
 
   winrt::Microsoft::UI::Composition::Compositor Compositor();
-  void Compositor(winrt::Microsoft::UI::Composition::Compositor const &compositor);
-
-  winrt::Microsoft::UI::Content::DesktopChildSiteBridge DesktopChildSiteBridge();
-  void DesktopChildSiteBridge(winrt::Microsoft::UI::Content::DesktopChildSiteBridge const &desktopChildSiteBridge);
-
-  winrt::Microsoft::UI::Dispatching::DispatcherQueueController DispatcherQueueController();
-  void DispatcherQueueController(
-      winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController);
 
   winrt::Microsoft::ReactNative::ReactNativeHost ReactNativeHost();
-  void ReactNativeHost(winrt::Microsoft::ReactNative::ReactNativeHost const &host);
 
-  winrt::Microsoft::ReactNative::ReactNativeIsland ReactNativeIsland();
-  void ReactNativeIsland(winrt::Microsoft::ReactNative::ReactNativeIsland const &reactNativeIsland);
+  winrt::Microsoft::ReactNative::ReactNativeWindow ReactNativeWindow() noexcept;
 
   winrt::Microsoft::ReactNative::ReactViewOptions ReactViewOptions();
   void ReactViewOptions(winrt::Microsoft::ReactNative::ReactViewOptions const &reactViewOptions);
@@ -36,12 +26,11 @@ struct ReactNativeWin32App : ReactNativeWin32AppT<ReactNativeWin32App> {
   void Start();
 
  private:
+  winrt::Microsoft::ReactNative::ReactNativeWindow m_rnWindow{nullptr};
   winrt::Microsoft::UI::Windowing::AppWindow m_appWindow{nullptr};
   winrt::Microsoft::UI::Composition::Compositor m_compositor{nullptr};
-  winrt::Microsoft::UI::Content::DesktopChildSiteBridge m_desktopChildSiteBridge{nullptr};
   winrt::Microsoft::UI::Dispatching::DispatcherQueueController m_dispatcherQueueController{nullptr};
   winrt::Microsoft::ReactNative::ReactNativeHost m_host{nullptr};
-  winrt::Microsoft::ReactNative::ReactNativeIsland m_reactNativeIsland{nullptr};
   winrt::Microsoft::ReactNative::ReactViewOptions m_reactViewOptions{nullptr};
 };
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactNativeWindow.idl

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import "ReactNativeIsland.idl";
+
+#include "NamespaceRedirect.h"
+#include "DocString.h"
+
+namespace Microsoft.ReactNative
+{
+
+  [experimental]
+  enum ContentSizePolicy
+  {
+    None,
+    ResizeContentToParentWindow,
+    ResizeParentWindowToContent,
+  };
+
+  [default_interface]
+  [webhosthidden]
+  [experimental]
+  DOC_STRING("Simplifies hosting a ReactNativeIsland inside a Window.")
+  runtimeclass ReactNativeWindow : Windows.Foundation.IClosable
+  {
+    static ReactNativeWindow CreateFromCompositor(Microsoft.UI.Composition.Compositor compositor);
+    static ReactNativeWindow CreateFromWindow(Microsoft.UI.Windowing.AppWindow appWindow, Microsoft.UI.Composition.Compositor compositor);
+    static ReactNativeWindow CreateFromContentSiteBridgeAndIsland(Microsoft.UI.Content.IContentSiteBridge bridge, Microsoft.ReactNative.ReactNativeIsland island);
+    static ReactNativeWindow CreateFromWindowAndIsland(Microsoft.UI.Windowing.AppWindow appWindow, Microsoft.ReactNative.ReactNativeIsland island);
+
+    ReactNativeIsland ReactNativeIsland { get; };
+
+    Microsoft.UI.Windowing.AppWindow AppWindow { get; };
+
+    Microsoft.UI.Content.IContentSiteBridge ContentSiteBridge { get; };
+    ContentSizePolicy ResizePolicy { get; set; };
+
+    DOC_STRING("When the ResizePolicy is set to ResizeParentWindowToContent, these LayoutConstraints will control the layout of the content."
+     " When ResizePolicy is set to ResizeContentToParentWindow, these constraints will be ignored. Instead the window can be constrained using"
+     " OverlappedPresenter.PreferredMaximumHeight etc.")
+    LayoutConstraints LayoutConstraints { get; set; };
+  }
+
+} // namespace Microsoft.ReactNative

package/Mso/src/dispatchQueue/queueService.cpp

@@ -205,8 +205,10 @@ void QueueService::InvokeTask(
   DispatchTask taskToInvoke{std::move(task)};
   taskToInvoke.Get()->Invoke(); // Call Get()->Invoke instead of operator() to flatten call stack
 
-  while (taskToInvoke = context.TakeNextDeferredTask()) {
+  taskToInvoke = context.TakeNextDeferredTask();
+  while (taskToInvoke) {
     taskToInvoke.Get()->Invoke();
+    taskToInvoke = context.TakeNextDeferredTask();
   }
 }