react-native-windows 0.74.23 → 0.74.24

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

@@ -127,6 +127,20 @@ ReactNativeIsland::ReactNativeIsland(const winrt::Microsoft::UI::Composition::Co
   InitTextScaleMultiplier();
 }
 
+// Constructor to initialize ReactNativeIsland with context and componentView
+ReactNativeIsland::ReactNativeIsland(
+    const winrt::Microsoft::UI::Composition::Compositor &compositor,
+    winrt::Microsoft::ReactNative::IReactContext context,
+    winrt::Microsoft::ReactNative::ComponentView componentView) noexcept
+    : m_compositor(compositor),
+      m_context(context),
+      m_layoutConstraints({{0, 0}, {0, 0}, winrt::Microsoft::ReactNative::LayoutDirection::Undefined}),
+      m_isFragment(true) {
+  m_rootTag = componentView.Tag();
+  InitTextScaleMultiplier();
+  AddFragmentCompositionEventHandler(context, componentView);
+}
+
 ReactNativeIsland::ReactNativeIsland() noexcept : ReactNativeIsland(nullptr) {}
 
 ReactNativeIsland::~ReactNativeIsland() noexcept {
@@ -152,6 +166,7 @@ ReactNative::IReactViewHost ReactNativeIsland::ReactViewHost() noexcept {
 }
 
 void ReactNativeIsland::ReactViewHost(winrt::Microsoft::ReactNative::IReactViewHost const &value) noexcept {
+  assert(!m_isFragment); // make sure this isn't a FragmentIsalnd
   if (m_reactViewHost == value) {
     return;
   }
@@ -404,7 +419,7 @@ void ReactNativeIsland::InitRootView(
 
   m_context = winrt::Microsoft::ReactNative::ReactContext(std::move(context));
   m_reactViewOptions = std::move(viewOptions);
-  m_CompositionEventHandler = std::make_shared<::Microsoft::ReactNative::CompositionEventHandler>(m_context, *this);
+  m_CompositionEventHandler = std::make_shared<::Microsoft::ReactNative::CompositionEventHandler>(m_context, *this, -1);
   m_CompositionEventHandler->Initialize();
 
   UpdateRootViewInternal();
@@ -412,6 +427,27 @@ void ReactNativeIsland::InitRootView(
   m_isInitialized = true;
 }
 
+void ReactNativeIsland::AddFragmentCompositionEventHandler(
+    winrt::Microsoft::ReactNative::IReactContext context,
+    winrt::Microsoft::ReactNative::ComponentView componentView) noexcept {
+  m_uiDispatcher = context.Properties()
+                       .Get(winrt::Microsoft::ReactNative::ReactDispatcherHelper::UIDispatcherProperty())
+                       .try_as<IReactDispatcher>();
+  VerifyElseCrash(m_uiDispatcher.HasThreadAccess());
+  VerifyElseCrash(m_rootTag != -1);
+  auto uiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
+      winrt::Microsoft::ReactNative::ReactPropertyBag(context.Properties()));
+
+  if (!m_CompositionEventHandler) {
+    // Create CompositionEventHandler if not already created
+    m_context = winrt::Microsoft::ReactNative::ReactContext(context);
+    m_CompositionEventHandler =
+        std::make_shared<::Microsoft::ReactNative::CompositionEventHandler>(m_context, *this, componentView.Tag());
+    m_CompositionEventHandler->Initialize();
+    m_isInitialized = true;
+  }
+}
+
 void ReactNativeIsland::UpdateRootView() noexcept {
   VerifyElseCrash(m_uiDispatcher.HasThreadAccess());
   VerifyElseCrash(m_isInitialized);
@@ -827,7 +863,9 @@ void ReactNativeIsland::OnMounted() noexcept {
     return;
   m_mounted = true;
   if (auto componentView = GetComponentView()) {
-    componentView->onMounted();
+    if (!componentView->isMounted()) {
+      componentView->onMounted();
+    }
   }
 }
 

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

@@ -48,6 +48,10 @@ struct ReactNativeIsland
   ~ReactNativeIsland() noexcept;
 
   ReactNativeIsland(const winrt::Microsoft::UI::Composition::Compositor &compositor) noexcept;
+  ReactNativeIsland(
+      const winrt::Microsoft::UI::Composition::Compositor &compositor,
+      winrt::Microsoft::ReactNative::IReactContext context,
+      winrt::Microsoft::ReactNative::ComponentView componentView) noexcept;
   winrt::Microsoft::UI::Content::ContentIsland Island();
 
   // property ReactViewHost
@@ -117,6 +121,10 @@ struct ReactNativeIsland
       const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
       facebook::react::Tag tag) noexcept;
 
+  void AddFragmentCompositionEventHandler(
+      winrt::Microsoft::ReactNative::IReactContext context,
+      winrt::Microsoft::ReactNative::ComponentView componentView) noexcept;
+
  public: // IReactViewInstance UI-thread implementation
   void InitRootView(
       winrt::Microsoft::ReactNative::IReactContext &&context,
@@ -136,6 +144,7 @@ struct ReactNativeIsland
 #endif
 
   HWND m_hwnd{0};
+  bool m_isFragment{false};
   bool m_isInitialized{false};
   bool m_isJSViewAttached{false};
   bool m_hasRenderedVisual{false};

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

@@ -7,6 +7,7 @@
 #include "RootComponentView.h"
 
 #include <Fabric/FabricUIManagerModule.h>
+#include <winrt/Microsoft.UI.Input.h>
 #include "CompositionRootAutomationProvider.h"
 #include "ReactNativeIsland.h"
 #include "Theme.h"
@@ -24,7 +25,7 @@ RootComponentView::RootComponentView(
           reactContext,
           ComponentViewFeatures::Default &
               ~(ComponentViewFeatures::Background | ComponentViewFeatures::ShadowProps |
-                ComponentViewFeatures::NativeBorder)) {}
+                ComponentViewFeatures::NativeBorder | ComponentViewFeatures::FocusVisual)) {}
 
 RootComponentView::~RootComponentView() {
   if (auto rootView = m_wkRootView.get()) {
@@ -106,7 +107,10 @@ bool RootComponentView::TrySetFocusedComponent(
   auto target = view;
   auto selfView = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(target);
   if (selfView && !selfView->focusable()) {
-    target = FocusManager::FindFirstFocusableElement(target);
+    target = (direction == winrt::Microsoft::ReactNative::FocusNavigationDirection::Last ||
+              direction == winrt::Microsoft::ReactNative::FocusNavigationDirection::Previous)
+        ? FocusManager::FindLastFocusableElement(target)
+        : FocusManager::FindFirstFocusableElement(target);
     if (!target)
       return false;
     selfView = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(target);
@@ -147,6 +151,9 @@ bool RootComponentView::TryMoveFocus(bool next) noexcept {
       [currentlyFocused = m_focusedComponent, next](const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
         if (view == currentlyFocused)
           return false;
+        auto selfView = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view);
+        if (!selfView->focusable())
+          return false;
 
         return winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(view)
             ->rootComponentView()
@@ -156,7 +163,28 @@ bool RootComponentView::TryMoveFocus(bool next) noexcept {
                      : winrt::Microsoft::ReactNative::FocusNavigationDirection::Previous);
       };
 
-  return winrt::Microsoft::ReactNative::implementation::walkTree(m_focusedComponent, next, fn);
+  if (winrt::Microsoft::ReactNative::implementation::walkTree(m_focusedComponent, next, fn)) {
+    return true;
+  }
+
+  // We reached the end of the focus loop.  Notify the island in case the host wants to move focus somewhere outside the
+  // island.
+  auto island = parentContentIsland();
+  if (island) {
+    auto focusController = winrt::Microsoft::UI::Input::InputFocusController::GetForIsland(island);
+    auto request = winrt::Microsoft::UI::Input::FocusNavigationRequest::Create(
+        next ? winrt::Microsoft::UI::Input::FocusNavigationReason::Last
+             : winrt::Microsoft::UI::Input::FocusNavigationReason::First);
+    auto result = focusController.DepartFocus(request);
+    if (result == winrt::Microsoft::UI::Input::FocusNavigationResult::Moved) {
+      return true;
+    }
+  }
+
+  // Wrap focus around if nothing outside the island takes focus
+  return NavigateFocus(winrt::Microsoft::ReactNative::FocusNavigationRequest(
+      next ? winrt::Microsoft::ReactNative::FocusNavigationReason::First
+           : winrt::Microsoft::ReactNative::FocusNavigationReason::Last));
 }
 
 HRESULT RootComponentView::GetFragmentRoot(IRawElementProviderFragmentRoot **pRetVal) noexcept {

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

@@ -1108,9 +1108,9 @@ void ScrollViewComponentView::StartBringIntoView(
         options.TargetRect->origin.y > m_scrollVisual.ScrollPosition().y) {
       needsScroll = true;
       if (options.TargetRect->size.height > viewerHeight) {
-        scrollToVertical = options.TargetRect->origin.y + options.VerticalOffset;
+        scrollToVertical = options.TargetRect->origin.y + options.VerticalOffset * m_layoutMetrics.pointScaleFactor;
       } else {
-        scrollToVertical = (targetBottom - viewerHeight) + options.VerticalOffset;
+        scrollToVertical = (targetBottom - viewerHeight) + options.VerticalOffset * m_layoutMetrics.pointScaleFactor;
       }
       // Scroll Up
     } else if (
@@ -1118,9 +1118,9 @@ void ScrollViewComponentView::StartBringIntoView(
         targetBottom < (m_scrollVisual.ScrollPosition().y + viewerHeight)) {
       needsScroll = true;
       if (options.TargetRect->size.height > viewerHeight) {
-        scrollToVertical = targetBottom - viewerHeight - options.VerticalOffset;
+        scrollToVertical = targetBottom - viewerHeight - options.VerticalOffset * m_layoutMetrics.pointScaleFactor;
       } else {
-        scrollToVertical = options.TargetRect->origin.y - options.VerticalOffset;
+        scrollToVertical = options.TargetRect->origin.y - options.VerticalOffset * m_layoutMetrics.pointScaleFactor;
       }
     }
   } else {
@@ -1134,9 +1134,9 @@ void ScrollViewComponentView::StartBringIntoView(
         options.TargetRect->origin.x > m_scrollVisual.ScrollPosition().x) {
       needsScroll = true;
       if (options.TargetRect->size.width > viewerWidth) {
-        scrollToHorizontal = options.TargetRect->origin.x + options.HorizontalOffset;
+        scrollToHorizontal = options.TargetRect->origin.x + options.HorizontalOffset * m_layoutMetrics.pointScaleFactor;
       } else {
-        scrollToHorizontal = (targetRight - viewerWidth) + options.HorizontalOffset;
+        scrollToHorizontal = (targetRight - viewerWidth) + options.HorizontalOffset * m_layoutMetrics.pointScaleFactor;
       }
       // Scroll Left
     } else if (
@@ -1144,9 +1144,9 @@ void ScrollViewComponentView::StartBringIntoView(
         targetRight < (m_scrollVisual.ScrollPosition().x + viewerWidth)) {
       needsScroll = true;
       if (options.TargetRect->size.width > viewerWidth) {
-        scrollToHorizontal = targetRight - viewerWidth - options.HorizontalOffset;
+        scrollToHorizontal = targetRight - viewerWidth - options.HorizontalOffset * m_layoutMetrics.pointScaleFactor;
       } else {
-        scrollToHorizontal = options.TargetRect->origin.x - options.HorizontalOffset;
+        scrollToHorizontal = options.TargetRect->origin.x - options.HorizontalOffset * m_layoutMetrics.pointScaleFactor;
       }
     }
   } else {

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.cpp

@@ -870,6 +870,7 @@ void WindowsTextInputComponentView::OnCharacterReceived(
   emitter->onKeyPress(onKeyPressArgs);
 
   WPARAM wParam = static_cast<WPARAM>(args.KeyCode());
+
   LPARAM lParam = 0;
   lParam = args.KeyStatus().RepeatCount; // bits 0-15
   lParam |= args.KeyStatus().ScanCode << 16; // bits 16-23
@@ -1022,6 +1023,10 @@ void WindowsTextInputComponentView::updateProps(
     m_submitKeyEvents.clear();
   }
 
+  if (oldTextInputProps.autoCapitalize != newTextInputProps.autoCapitalize) {
+    autoCapitalizeOnUpdateProps(oldTextInputProps.autoCapitalize, newTextInputProps.autoCapitalize);
+  }
+
   UpdatePropertyBits();
 }
 
@@ -1476,4 +1481,29 @@ winrt::Microsoft::ReactNative::ComponentView WindowsTextInputComponentView::Crea
   return winrt::make<WindowsTextInputComponentView>(compContext, tag, reactContext);
 }
 
-} // namespace winrt::Microsoft::ReactNative::Composition::implementation
+// This function assumes that previous and new capitalization types are different.
+void WindowsTextInputComponentView::autoCapitalizeOnUpdateProps(
+    const std::string &previousCapitalizationType,
+    const std::string &newCapitalizationType) noexcept {
+  /*
+    Possible values are:
+     Characters - All characters.
+     Words - First letter of each word.
+     Sentences - First letter of each sentence.
+     None - Do not autocapitalize anything.
+
+     For now, only characters and none are supported.
+  */
+
+  if (previousCapitalizationType == "characters") {
+    winrt::check_hresult(m_textServices->TxSendMessage(
+        EM_SETEDITSTYLE, 0 /* disable */, SES_UPPERCASE /* flag affected */, nullptr /* LRESULT */));
+  }
+
+  if (newCapitalizationType == "characters") {
+    winrt::check_hresult(m_textServices->TxSendMessage(
+        EM_SETEDITSTYLE, SES_UPPERCASE /* enable */, SES_UPPERCASE /* flag affected */, nullptr /* LRESULT */));
+  }
+}
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.h

@@ -104,6 +104,10 @@ struct WindowsTextInputComponentView
   void InternalFinalize() noexcept;
   void UpdatePropertyBits() noexcept;
 
+  void autoCapitalizeOnUpdateProps(
+      const std::string &previousCapitalizationType,
+      const std::string &newcapitalizationType) noexcept;
+
   winrt::Windows::UI::Composition::CompositionSurfaceBrush m_brush{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::ICaretVisual m_caretVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IDrawingSurfaceBrush m_drawingSurface{nullptr};

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

@@ -330,7 +330,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"AcrylicInAppFillColorDefault", {0x9E, 0xFF, 0xFF, 0xFF}},
           {"SystemChromeMediumLowColor", {0xFF, 0xF2, 0xF2, 0xF2}},
           {"SystemControlForegroundBaseHighColor", {0xFF, 0x00, 0x00, 0x00}},
-          {"SystemControlTransientBorderColor", {0x24, 0x00, 0x00, 0x00}}};
+          {"SystemControlTransientBorderColor", {0x24, 0x00, 0x00, 0x00}},
+          {"FocusVisualPrimary", {0xFF, 0x00, 0x00, 0x00}},
+          {"FocusVisualSecondary", {0x99, 0xFF, 0xFF, 0xFF}}};
 
   static std::unordered_map<std::string, winrt::Windows::UI::Color, std::hash<std::string_view>, std::equal_to<>>
       s_darkColors = {
@@ -362,7 +364,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"AcrylicInAppFillColorDefault", {0x9E, 0x00, 0x00, 0x00}},
           {"SystemChromeMediumLowColor", {0xFF, 0x2B, 0x2B, 0x2B}},
           {"SystemControlForegroundBaseHighColor", {0xFF, 0xFF, 0xFF, 0xFF}},
-          {"SystemControlTransientBorderColor", {0x5C, 0x00, 0x00, 0x00}}};
+          {"SystemControlTransientBorderColor", {0x5C, 0x00, 0x00, 0x00}},
+          {"FocusVisualPrimary", {0xFF, 0xFF, 0xFF, 0xFF}},
+          {"FocusVisualSecondary", {0x99, 0x00, 0x00, 0x00F}}};
 
   static std::unordered_map<
       std::string,
@@ -399,7 +403,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ControlStrongFillColorDisabled", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
           {"SystemChromeMediumLowColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
           {"SystemControlForegroundBaseHighColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
-          {"SystemControlTransientBorderColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}}};
+          {"SystemControlTransientBorderColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
+          {"FocusVisualPrimary", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
+          {"FocusVisualSecondary", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}}};
 
   auto alias = s_xamlAliasedColors.find(platformColor);
   if (alias != s_xamlAliasedColors.end()) {

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

@@ -214,4 +214,15 @@ ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
   }
 }
 
+ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept {
+  if (state.has_value()) {
+    if (state->checked == facebook::react::AccessibilityState::Checked) {
+      return ToggleState::ToggleState_On;
+    } else if (state->checked == facebook::react::AccessibilityState::Mixed) {
+      return ToggleState::ToggleState_Indeterminate;
+    }
+  }
+  return ToggleState::ToggleState_Off;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -36,4 +36,6 @@ std::string extractAccessibilityValue(const facebook::react::AccessibilityValue
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
 
 ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
+
+ToggleState GetToggleState(const std::optional<facebook::react::AccessibilityState> &state) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/IReactCompositionViewComponentBuilder.idl

@@ -33,6 +33,7 @@ namespace Microsoft.ReactNative.Composition
     void SetViewComponentViewInitializer(ViewComponentViewInitializer initializer);
     void SetContentIslandComponentViewInitializer(ComponentIslandComponentViewInitializer initializer);
     void SetCreateVisualHandler(CreateVisualDelegate impl);
+    void SetViewFeatures(ComponentViewFeatures viewFeatures);
   };
 
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/IReactViewComponentBuilder.idl

@@ -56,7 +56,7 @@ namespace Microsoft.ReactNative
 
   [experimental]
   DOC_STRING("A delegate that creates a @IComponentProps object for an instance of @ViewProps. See @IReactViewComponentBuilder.SetCreateProps")
-  delegate IComponentProps ViewPropsFactory(ViewProps props);
+  delegate IComponentProps ViewPropsFactory(ViewProps props, IComponentProps cloneFrom);
 
   [experimental]
   delegate Windows.Foundation.Size MeasureContentHandler(ShadowNode shadowNode, LayoutContext layoutContext, LayoutConstraints layoutConstraints);

package/Microsoft.ReactNative/ReactNativeAppBuilder.cpp

@@ -1,43 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
 #include "pch.h"
 #include "ReactNativeAppBuilder.h"
 #include "ReactNativeAppBuilder.g.cpp"
-#include "IReactDispatcher.h"
-#include "ReactNativeHost.h"
+
 #include "ReactNativeWin32App.h"
+
+#include "winrt/Microsoft.ReactNative.h"
 #include "winrt/Microsoft.UI.Composition.h"
 #include "winrt/Microsoft.UI.Dispatching.h"
+#include "winrt/Microsoft.UI.Interop.h"
 #include "winrt/Microsoft.UI.Windowing.h"
-#include "winrt/microsoft.UI.Interop.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::ReactNative {
-using namespace winrt::Microsoft::ReactNative;
-}
-
-namespace winrt::UI {
-using namespace winrt::Microsoft::UI;
-}
 
 namespace winrt::Microsoft::ReactNative::implementation {
 ReactNativeAppBuilder::ReactNativeAppBuilder() {
@@ -46,133 +20,55 @@ ReactNativeAppBuilder::ReactNativeAppBuilder() {
 
 ReactNativeAppBuilder::~ReactNativeAppBuilder() {}
 
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::AddPackageProviders(
-    winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::ReactNative::IReactPackageProvider> const
-        &packageProviders) {
-  for (auto const &provider : packageProviders) {
-    m_reactNativeWin32App.ReactNativeHost().PackageProviders().Append(provider);
-  }
-
-  return *this;
-}
-
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetReactInstanceSettings(
-    winrt::Microsoft::ReactNative::ReactInstanceSettings const &settings) {
-  m_reactNativeWin32App.ReactNativeHost().InstanceSettings(settings);
-
+winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetDispatcherQueueController(
+    winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController) {
+  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
+      dispatcherQueueController);
   return *this;
 }
 
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetCompositor(
+winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetCompositor(
     winrt::Microsoft::UI::Composition::Compositor const &compositor) {
   m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->Compositor(compositor);
   return *this;
 }
 
-winrt::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetAppWindow(
+winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetAppWindow(
     winrt::Microsoft::UI::Windowing::AppWindow const &appWindow) {
   m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
 
   return *this;
 }
 
-winrt::Microsoft::ReactNative::ReactNativeAppBuilder ReactNativeAppBuilder::SetReactViewOptions(
-    winrt::Microsoft::ReactNative::ReactViewOptions const &reactViewOptions) {
-  m_reactViewOptions = reactViewOptions;
+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);
 
-  return *this;
-}
-
-winrt::ReactNative::ReactNativeWin32App ReactNativeAppBuilder::Build() {
-  if (m_reactNativeWin32App.Compositor() == nullptr) {
-    // Create a DispatcherQueue for this thread.  This is needed for Composition, Content, and
-    // Input APIs.
+    // 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()->DispatchQueueController(
+    m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DispatcherQueueController(
         dispatcherQueueController);
+  }
 
-    // Create the compositor on behalf of the App Developer
+  // 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 developer doesn't provide one
+  // 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"SampleApplication");
+    appWindow.Title(L"ReactNativeWin32App");
     appWindow.Resize({1000, 1000});
-    appWindow.Show();
 
     m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->AppWindow(appWindow);
   }
 
-  // Currently set the property to use current thread dispatcher as a default UI dispatcher.
-  // TODO: Provision for setting dispatcher based on the thread dispatcherQueueController is created.
-  m_reactNativeWin32App.ReactNativeHost().InstanceSettings().Properties().Set(
-      ReactDispatcherHelper::UIDispatcherProperty(), ReactDispatcherHelper::UIThreadDispatcher());
-
-  auto hwnd{winrt::UI::GetWindowFromWindowId(m_reactNativeWin32App.AppWindow().Id())};
-
-  winrt::ReactNative::ReactCoreInjection::SetTopLevelWindowId(
-      m_reactNativeWin32App.ReactNativeHost().InstanceSettings().Properties(), reinterpret_cast<uint64_t>(hwnd));
-
-  winrt::ReactNative::Composition::CompositionUIService::SetCompositor(
-      m_reactNativeWin32App.ReactNativeHost().InstanceSettings(), m_reactNativeWin32App.Compositor());
-
-  // Start the react-native instance, which will create a JavaScript runtime and load the applications bundle.
-  m_reactNativeWin32App.ReactNativeHost().ReloadInstance();
-
-  // Create a RootView which will present a react-native component
-  auto reactNativeIsland = winrt::Microsoft::ReactNative::ReactNativeIsland(m_reactNativeWin32App.Compositor());
-  reactNativeIsland.ReactViewHost(winrt::Microsoft::ReactNative::ReactCoreInjection::MakeViewHost(
-      m_reactNativeWin32App.ReactNativeHost(), m_reactViewOptions));
-
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->ReactNativeIsland(
-      std::move(reactNativeIsland));
-
-  // Update the size of the RootView when the AppWindow changes size
-  m_reactNativeWin32App.AppWindow().Changed(
-      [wkRootView = winrt::make_weak(m_reactNativeWin32App.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_reactNativeWin32App.AppWindow().Destroying([this](
-                                                   winrt::Microsoft::UI::Windowing::AppWindow const &window,
-                                                   winrt::Windows::Foundation::IInspectable const & /*args*/) {
-    // Before we shutdown the application - unload the ReactNativeHost to give the javascript a chance to save any
-    // state
-    auto async = m_reactNativeWin32App.ReactNativeHost().UnloadInstance();
-    async.Completed([this](auto asyncInfo, winrt::Windows::Foundation::AsyncStatus asyncStatus) {
-      assert(asyncStatus == winrt::Windows::Foundation::AsyncStatus::Completed);
-      m_reactNativeWin32App.ReactNativeHost().InstanceSettings().UIDispatcher().Post([]() { PostQuitMessage(0); });
-    });
-  });
-
-  // DesktopChildSiteBridge create a ContentSite that can host the RootView ContentIsland
-  auto desktopChildSiteBridge = winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(
-      m_reactNativeWin32App.Compositor(), m_reactNativeWin32App.AppWindow().Id());
-
-  desktopChildSiteBridge.Connect(m_reactNativeWin32App.ReactNativeIsland().Island());
-
-  desktopChildSiteBridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
-
-  auto scaleFactor = ScaleFactor(hwnd);
-  m_reactNativeWin32App.ReactNativeIsland().ScaleFactor(scaleFactor);
-
-  UpdateRootViewSizeToAppWindow(reactNativeIsland, m_reactNativeWin32App.AppWindow());
-
-  m_reactNativeWin32App.as<implementation::ReactNativeWin32App>().get()->DesktopChildSiteBridge(
-      std::move(desktopChildSiteBridge));
-
   return m_reactNativeWin32App;
 }
 

package/Microsoft.ReactNative/ReactNativeAppBuilder.h

@@ -1,6 +1,8 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
 #pragma once
+
 #include "ReactNativeAppBuilder.g.h"
-#include <winrt/Microsoft.UI.Content.h>
 
 namespace winrt::Microsoft::ReactNative::implementation {
 struct ReactNativeAppBuilder : ReactNativeAppBuilderT<ReactNativeAppBuilder> {
@@ -8,25 +10,15 @@ struct ReactNativeAppBuilder : ReactNativeAppBuilderT<ReactNativeAppBuilder> {
 
   ~ReactNativeAppBuilder();
 
-  winrt::Microsoft::ReactNative::ReactNativeAppBuilder AddPackageProviders(
-      winrt::Windows::Foundation::Collections::IVector<winrt::Microsoft::ReactNative::IReactPackageProvider> const
-          &packageProviders);
-  winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetReactInstanceSettings(
-      winrt::Microsoft::ReactNative::ReactInstanceSettings const &settings);
-
-  // TODO: Currently, SetCompositor API is not exposed to the developer.
-  // Compositor depends on the DispatcherQueue created by DispatcherQueueController on a current thread
-  // or dedicated thread. So we also have to make a provision for setting DispatcherQueueController.
+  winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetDispatcherQueueController(
+      winrt::Microsoft::UI::Dispatching::DispatcherQueueController const &dispatcherQueueController);
   winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetCompositor(
       winrt::Microsoft::UI::Composition::Compositor const &compositor);
   winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetAppWindow(
       winrt::Microsoft::UI::Windowing::AppWindow const &appWindow);
-  winrt::Microsoft::ReactNative::ReactNativeAppBuilder SetReactViewOptions(
-      winrt::Microsoft::ReactNative::ReactViewOptions const &reactViewOptions);
   winrt::Microsoft::ReactNative::ReactNativeWin32App Build();
 
  private:
-  winrt::Microsoft::ReactNative::ReactViewOptions m_reactViewOptions{};
   winrt::Microsoft::ReactNative::ReactNativeWin32App m_reactNativeWin32App{nullptr};
 };
 } // namespace winrt::Microsoft::ReactNative::implementation