react-native-windows 0.72.13 → 0.73.0-preview.1

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

@@ -28,22 +28,34 @@ typedef int PointerId;
 
 class CompositionEventHandler {
  public:
-  CompositionEventHandler(const winrt::Microsoft::ReactNative::ReactContext &context);
   CompositionEventHandler(
       const winrt::Microsoft::ReactNative::ReactContext &context,
       const winrt::Microsoft::ReactNative::CompositionRootView &CompositionRootView);
   virtual ~CompositionEventHandler();
 
   int64_t SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept;
-  void ScrollWheel(facebook::react::Point pt, uint32_t delta);
   void RemoveTouchHandlers();
+  winrt::Windows::UI::Core::CoreVirtualKeyStates GetKeyState(winrt::Windows::System::VirtualKey key) noexcept;
 
  private:
-  void ButtonDown(uint32_t msg, uint64_t wParam, int64_t lParam);
-  void PointerPressed(uint32_t msg, uint64_t wParam, int64_t lParam);
-  void ButtonUp(uint32_t msg, uint64_t wParam, int64_t lParam);
-  void PointerUp(uint32_t msg, uint64_t wParam, int64_t lParam);
-  void MouseMove(uint32_t msg, uint64_t wParam, int64_t lParam);
+  void onPointerPressed(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onPointerReleased(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onPointerMoved(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onPointerWheelChanged(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onKeyDown(
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept;
+  void onKeyUp(
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept;
 
   facebook::react::SurfaceId SurfaceId() noexcept;
   RootComponentView &RootComponentView() noexcept;
@@ -54,10 +66,16 @@ class CompositionEventHandler {
     Touch,
   };
   enum class TouchEventType { Start = 0, End, Move, Cancel, CaptureLost, PointerEntered, PointerExited, PointerMove };
-  void DispatchTouchEvent(TouchEventType eventType, PointerId pointerId);
+  void DispatchTouchEvent(
+      TouchEventType eventType,
+      PointerId pointerId,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers);
   void HandleIncomingPointerEvent(
       facebook::react::PointerEvent &pe,
       IComponentView *targetView,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers,
       std::function<void(std::vector<IComponentView *> &)> handler);
 
   struct ActiveTouch {
@@ -115,6 +133,15 @@ class CompositionEventHandler {
   std::map<PointerId, std::vector<ReactTaggedView>> m_currentlyHoveredViewsPerPointer;
   winrt::Microsoft::ReactNative::CompositionRootView m_compRootView{nullptr};
   winrt::Microsoft::ReactNative::ReactContext m_context;
+
+#ifdef USE_WINUI3
+  winrt::event_token m_pointerPressedToken;
+  winrt::event_token m_pointerReleasedToken;
+  winrt::event_token m_pointerMovedToken;
+  winrt::event_token m_pointerWheelChangedToken;
+  winrt::event_token m_keyDownToken;
+  winrt::event_token m_keyUpToken;
+#endif
 };
 
 } // namespace Microsoft::ReactNative

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

@@ -11,30 +11,68 @@ namespace Microsoft::ReactNative {
 
 namespace Composition {
 
+// Windows composition specific interface to extract the inner compositor object
+MSO_STRUCT_GUID(IWindowsCompositionCompositor, "4FA84446-B662-440F-AE53-43A223D2068E")
+struct IWindowsCompositionCompositor : public IUnknown {
+  virtual winrt::Windows::UI::Composition::Compositor InnerCompositor() const noexcept = 0;
+};
+
 // Windows composition specific interface to extract the inner composition object
-MSO_STRUCT_GUID(ICompositionVisual, "2F7F7E82-0BEA-4Cf8-9531-E81338754187")
-struct ICompositionVisual : public IUnknown {
+MSO_STRUCT_GUID(IWindowsCompositionVisual, "2F7F7E82-0BEA-4Cf8-9531-E81338754187")
+struct IWindowsCompositionVisual : public IUnknown {
   virtual winrt::Windows::UI::Composition::Visual InnerVisual() const noexcept = 0;
 };
 
 // Windows composition specific interface to extract the inner composition shadow object
-MSO_STRUCT_GUID(ICompositionDropShadow, "C6474C79-B99A-4312-8FE6-7BC0C9594E5C")
-struct ICompositionDropShadow : public IUnknown {
+MSO_STRUCT_GUID(IWindowsCompositionDropShadow, "C6474C79-B99A-4312-8FE6-7BC0C9594E5C")
+struct IWindowsCompositionDropShadow : public IUnknown {
   virtual winrt::Windows::UI::Composition::DropShadow InnerShadow() const noexcept = 0;
 };
 
 // Windows composition specific interface to extract the inner composition brush object
-MSO_STRUCT_GUID(ICompositionBrush, "CFD63CA2-856E-4D5D-B2E2-68B982407051")
-struct ICompositionBrush : public IUnknown {
+MSO_STRUCT_GUID(IWindowsCompositionBrush, "CFD63CA2-856E-4D5D-B2E2-68B982407051")
+struct IWindowsCompositionBrush : public IUnknown {
   virtual winrt::Windows::UI::Composition::CompositionBrush InnerBrush() const noexcept = 0;
 };
 
 // Windows composition specific interface to extract the drawing surface object
-MSO_STRUCT_GUID(ICompositionDrawingSurfaceInner, "985963C3-1133-43CA-BAD2-AC4C893C3A1F")
-struct ICompositionDrawingSurfaceInner : public IUnknown {
+MSO_STRUCT_GUID(IWindowsCompositionDrawingSurfaceInner, "985963C3-1133-43CA-BAD2-AC4C893C3A1F")
+struct IWindowsCompositionDrawingSurfaceInner : public IUnknown {
   virtual winrt::Windows::UI::Composition::ICompositionSurface Inner() const noexcept = 0;
 };
 
+#ifdef USE_WINUI3
+// Windows composition specific interface to extract the inner compositor object
+MSO_STRUCT_GUID(IMicrosoftCompositionCompositor, "B7B3E027-6A87-4946-B397-247AAB8634C6")
+struct IMicrosoftCompositionCompositor : public IUnknown {
+  virtual winrt::Microsoft::UI::Composition::Compositor InnerCompositor() const noexcept = 0;
+};
+
+// Microsoft composition specific interface to extract the inner composition object
+MSO_STRUCT_GUID(IMicrosoftCompositionVisual, "FF8731D8-8AFA-4F6F-9E76-7F538F3C1157")
+struct IMicrosoftCompositionVisual : public IUnknown {
+  virtual winrt::Microsoft::UI::Composition::Visual InnerVisual() const noexcept = 0;
+};
+
+// Microsoft composition specific interface to extract the inner composition shadow object
+MSO_STRUCT_GUID(IMicrosoftCompositionDropShadow, "78E94CC1-8E8A-4CF7-9301-23305FFC97A2")
+struct IMicrosoftCompositionDropShadow : public IUnknown {
+  virtual winrt::Microsoft::UI::Composition::DropShadow InnerShadow() const noexcept = 0;
+};
+
+// Microsoft composition specific interface to extract the inner composition brush object
+MSO_STRUCT_GUID(IMicrosoftCompositionBrush, "831CA206-B777-4660-88BC-19EB78045E40")
+struct IMicrosoftCompositionBrush : public IUnknown {
+  virtual winrt::Microsoft::UI::Composition::CompositionBrush InnerBrush() const noexcept = 0;
+};
+
+// Microsoft composition specific interface to extract the drawing surface object
+MSO_STRUCT_GUID(IMicrosoftCompositionDrawingSurfaceInner, "4ADDC62F-51D0-4C71-8BE4-3256E628D07A")
+struct IMicrosoftCompositionDrawingSurfaceInner : public IUnknown {
+  virtual winrt::Microsoft::UI::Composition::ICompositionSurface Inner() const noexcept = 0;
+};
+#endif
+
 } // namespace Composition
 
 bool CheckForDeviceRemoved(HRESULT hr);

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

@@ -61,13 +61,14 @@ void CompositionHwndHost::Initialize(uint64_t hwnd) noexcept {
 
   m_compRootView.ScaleFactor(ScaleFactor());
   m_compRootView.RootVisual(
-      winrt::Microsoft::ReactNative::Composition::implementation::CompositionContextHelper::CreateVisual(RootVisual()));
+      winrt::Microsoft::ReactNative::Composition::implementation::WindowsCompositionContextHelper::CreateVisual(
+          RootVisual()));
 
   UpdateSize();
 }
 
-double CompositionHwndHost::ScaleFactor() noexcept {
-  return GetDpiForWindow(m_hwnd) / 96.0;
+float CompositionHwndHost::ScaleFactor() noexcept {
+  return GetDpiForWindow(m_hwnd) / 96.0f;
 }
 
 void CompositionHwndHost::UpdateSize() noexcept {
@@ -90,23 +91,6 @@ LRESULT CompositionHwndHost::TranslateMessage(int msg, uint64_t wParam, int64_t
     return 0;
 
   switch (msg) {
-    case WM_MOUSEWHEEL: {
-      POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
-      ::ScreenToClient(m_hwnd, &pt);
-      int32_t delta = GET_WHEEL_DELTA_WPARAM(wParam);
-      m_compRootView.OnScrollWheel({static_cast<float>(pt.x), static_cast<float>(pt.y)}, delta);
-      return 0;
-    }
-    /*
-    case WM_POINTERDOWN: {
-      m_compRootView.OnPointerPressed({GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)});
-      return 0;
-    }
-    case WM_LBUTTONUP: {
-      m_compRootView.OnMouseUp({static_cast<float>(GET_X_LPARAM(lParam)), static_cast<float>(GET_Y_LPARAM(lParam))});
-      return 0;
-    }
-    */
     case WM_WINDOWPOSCHANGED: {
       UpdateSize();
       /*
@@ -149,7 +133,7 @@ winrt::Windows::UI::Composition::Compositor CompositionHwndHost::Compositor() co
       winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
           m_reactViewHost.ReactNativeHost().InstanceSettings().Properties());
 
-  return winrt::Microsoft::ReactNative::Composition::implementation::CompositionContextHelper::InnerCompositor(
+  return winrt::Microsoft::ReactNative::Composition::implementation::WindowsCompositionContextHelper::InnerCompositor(
       compositionContext);
 }
 

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

@@ -38,7 +38,7 @@ struct CompositionHwndHost : CompositionHwndHostT<CompositionHwndHost> {
   void CreateDesktopWindowTarget(HWND window);
   void CreateCompositionRoot();
   void UpdateSize() noexcept;
-  double ScaleFactor() noexcept;
+  float ScaleFactor() noexcept;
 
   HWND m_hwnd;
   winrt::Microsoft::ReactNative::CompositionRootView m_compRootView{nullptr};

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

@@ -1,7 +1,12 @@
 #include "pch.h"
 #include "CompositionRootAutomationProvider.h"
+#include <algorithm>
 #include "UiaHelpers.h"
 
+#ifdef USE_WINUI3
+#include <winrt/Microsoft.UI.Content.h>
+#endif
+
 namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionRootAutomationProvider::CompositionRootAutomationProvider(
@@ -32,7 +37,7 @@ HRESULT __stdcall CompositionRootAutomationProvider::GetEmbeddedFragmentRoots(SA
 }
 
 HRESULT __stdcall CompositionRootAutomationProvider::SetFocus(void) {
-  return S_OK;
+  return UiaSetFocusHelper(m_view);
 }
 
 HRESULT __stdcall CompositionRootAutomationProvider::GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) {
@@ -55,6 +60,15 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_HostRawElementProvider(
   if (pRetVal == nullptr)
     return E_POINTER;
 
+#ifdef USE_WINUI3
+  if (m_island) {
+    winrt::Windows::Foundation::IInspectable host = m_island.GetAutomationHostProvider();
+    *pRetVal = host.as<IRawElementProviderSimple>().detach();
+    return S_OK;
+  }
+#endif
+
+  // TODO: assumes windowed
   if (!IsWindow(m_hwnd))
     return UIA_E_ELEMENTNOTAVAILABLE;
 
@@ -67,6 +81,39 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_BoundingRectangle(UiaRe
   if (pRetVal == nullptr)
     return E_POINTER;
 
+#ifdef USE_WINUI3
+  if (m_island) {
+    auto cc = m_island.CoordinateConverter();
+    auto origin = cc.ConvertLocalToScreen(winrt::Windows::Foundation::Point{0, 0});
+    pRetVal->left = origin.X;
+    pRetVal->top = origin.Y;
+
+    auto size = m_island.ActualSize();
+    pRetVal->width = size.x;
+    pRetVal->height = size.y;
+
+    return S_OK;
+  }
+#endif
+
+  // TODO: Need host site offsets
+  // Assume we're hosted in some other visual-based hosting site
+  if (m_hwnd == nullptr || !IsWindow(m_hwnd)) {
+    return UiaGetBoundingRectangleHelper(m_view, *pRetVal);
+  }
+
+  POINT point{0, 0};
+  ClientToScreen(m_hwnd, &point);
+  pRetVal->left = point.x;
+  pRetVal->top = point.y;
+  RECT rect;
+  GetClientRect(m_hwnd, &rect);
+  point.x = rect.right;
+  point.y = rect.bottom;
+  ClientToScreen(m_hwnd, &point);
+  pRetVal->width = point.x - pRetVal->left;
+  pRetVal->height = point.y - pRetVal->top;
+
   return S_OK;
 }
 
@@ -97,6 +144,28 @@ HRESULT __stdcall CompositionRootAutomationProvider::ElementProviderFromPoint(
 
   *pRetVal = nullptr;
 
+  auto strongView = m_view.view();
+
+  if (strongView == nullptr) {
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  }
+
+  auto spRootView = std::static_pointer_cast<::Microsoft::ReactNative::RootComponentView>(strongView);
+
+  if (m_hwnd == nullptr || !IsWindow(m_hwnd)) {
+    // TODO: Add support for non-HWND based hosting
+    return E_FAIL;
+  }
+
+  POINT clientPoint{static_cast<LONG>(x), static_cast<LONG>(y)};
+  ScreenToClient(m_hwnd, &clientPoint);
+
+  auto provider = spRootView->UiaProviderFromPoint(clientPoint);
+  auto spFragment = provider.try_as<IRawElementProviderFragment>();
+  if (spFragment) {
+    *pRetVal = spFragment.detach();
+  }
+
   return S_OK;
 }
 
@@ -117,9 +186,10 @@ HRESULT __stdcall CompositionRootAutomationProvider::GetFocus(IRawElementProvide
 
   if (focusedComponent) {
     auto focusedUiaProvider = focusedComponent->EnsureUiaProvider();
-    winrt::com_ptr<IRawElementProviderFragment> spFragment;
-    focusedUiaProvider.as(spFragment);
-    *pRetVal = spFragment.detach();
+    auto spFragment = focusedUiaProvider.try_as<IRawElementProviderFragment>();
+    if (spFragment) {
+      *pRetVal = spFragment.detach();
+    }
   }
 
   return S_OK;
@@ -129,6 +199,12 @@ void CompositionRootAutomationProvider::SetHwnd(HWND hwnd) noexcept {
   m_hwnd = hwnd;
 }
 
+#ifdef USE_WINUI3
+void CompositionRootAutomationProvider::SetIsland(winrt::Microsoft::UI::Content::ContentIsland &island) noexcept {
+  m_island = island;
+}
+#endif
+
 HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
     NavigateDirection direction,
     IRawElementProviderFragment **pRetVal) {
@@ -144,4 +220,156 @@ HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
   return S_OK;
 }
 
+// RAII wrapper to unaccess SafeArray data so I can early return in the relevant functions
+class SafeArrayAccessScope {
+  SAFEARRAY *m_pArray = nullptr;
+
+ public:
+  SafeArrayAccessScope(SAFEARRAY *psa) noexcept : m_pArray(psa) {}
+  ~SafeArrayAccessScope() noexcept {
+    if (m_pArray != nullptr)
+      SafeArrayUnaccessData(m_pArray);
+  }
+};
+
+void AdviseEventAddedImpl(
+    std::vector<CompositionRootAutomationProvider::AdvisedEvent> &advisedEvents,
+    EVENTID idEvent) noexcept {
+  auto it = std::find_if(
+      advisedEvents.begin(),
+      advisedEvents.end(),
+      [idEvent](const CompositionRootAutomationProvider::AdvisedEvent &ae) noexcept { return ae.Event == idEvent; });
+
+  if (it == advisedEvents.end()) {
+    advisedEvents.emplace_back(CompositionRootAutomationProvider::AdvisedEvent{idEvent, 1 /*Count*/});
+  } else {
+    it->Count++;
+  }
+}
+
+HRESULT CompositionRootAutomationProvider::AdvisePropertiesAdded(SAFEARRAY *psaProperties) noexcept {
+  if (psaProperties == nullptr)
+    return E_POINTER;
+
+  long *pValues = nullptr;
+  auto hr = SafeArrayAccessData(psaProperties, reinterpret_cast<void **>(&pValues));
+  if (FAILED(hr))
+    return hr;
+
+  SafeArrayAccessScope accessScope(psaProperties);
+
+  if (SafeArrayGetDim(psaProperties) != 1)
+    return E_INVALIDARG;
+
+  VARTYPE vt;
+  hr = SafeArrayGetVartype(psaProperties, &vt);
+  if (FAILED(hr) || vt != VT_I4)
+    return E_INVALIDARG;
+
+  long lower;
+  hr = SafeArrayGetLBound(psaProperties, 1, &lower);
+  if (FAILED(hr))
+    return hr;
+
+  long upper;
+  hr = SafeArrayGetUBound(psaProperties, 1, &upper);
+  if (FAILED(hr))
+    return hr;
+
+  long count = upper - lower + 1;
+
+  for (int i = 0; i < count; i++) {
+    AdviseEventAddedImpl(m_advisedProperties, pValues[i]);
+  }
+  return S_OK;
+}
+
+HRESULT CompositionRootAutomationProvider::AdviseEventAdded(EVENTID idEvent, SAFEARRAY *psaProperties) {
+  if (idEvent == UIA_AutomationPropertyChangedEventId) {
+    return AdvisePropertiesAdded(psaProperties);
+  }
+  AdviseEventAddedImpl(m_advisedEvents, idEvent);
+  return S_OK;
+}
+
+HRESULT AdviseEventRemovedImpl(
+    std::vector<CompositionRootAutomationProvider::AdvisedEvent> &advisedEvents,
+    EVENTID idEvent) noexcept {
+  auto it = std::find_if(
+      advisedEvents.begin(),
+      advisedEvents.end(),
+      [idEvent](const CompositionRootAutomationProvider::AdvisedEvent &ae) noexcept { return ae.Event == idEvent; });
+
+  if (it == advisedEvents.end()) {
+    assert(false);
+    return UIA_E_INVALIDOPERATION;
+  } else if (it->Count == 1) {
+    advisedEvents.erase(it);
+  } else {
+    it->Count--;
+  }
+  return S_OK;
+}
+
+HRESULT CompositionRootAutomationProvider::AdvisePropertiesRemoved(SAFEARRAY *psaProperties) noexcept {
+  if (psaProperties == nullptr)
+    return E_POINTER;
+
+  long *pValues = nullptr;
+  auto hr = SafeArrayAccessData(psaProperties, reinterpret_cast<void **>(&pValues));
+  if (FAILED(hr))
+    return hr;
+
+  SafeArrayAccessScope accessScope(psaProperties);
+
+  if (SafeArrayGetDim(psaProperties) != 1)
+    return E_INVALIDARG;
+
+  VARTYPE vt;
+  hr = SafeArrayGetVartype(psaProperties, &vt);
+  if (FAILED(hr) || vt != VT_I4)
+    return E_INVALIDARG;
+
+  long lower;
+  hr = SafeArrayGetLBound(psaProperties, 1, &lower);
+  if (FAILED(hr))
+    return hr;
+
+  long upper;
+  hr = SafeArrayGetUBound(psaProperties, 1, &upper);
+  if (FAILED(hr))
+    return hr;
+
+  long count = upper - lower + 1;
+  auto returnHr = S_OK;
+  for (int i = 0; i < count; i++) {
+    auto hr = AdviseEventRemovedImpl(m_advisedProperties, pValues[i]);
+    if (FAILED(hr)) {
+      returnHr = hr;
+    }
+  }
+  return returnHr;
+}
+
+HRESULT
+CompositionRootAutomationProvider::AdviseEventRemoved(EVENTID idEvent, SAFEARRAY *psaProperties) {
+  if (idEvent == UIA_AutomationPropertyChangedEventId) {
+    return AdvisePropertiesRemoved(psaProperties);
+  }
+
+  return AdviseEventRemovedImpl(m_advisedEvents, idEvent);
+}
+
+bool CompositionRootAutomationProvider::WasEventAdvised(EVENTID event) noexcept {
+  return std::any_of(m_advisedEvents.begin(), m_advisedEvents.end(), [event](const AdvisedEvent &ae) {
+    return ae.Event == event && ae.Count > 0;
+  });
+}
+
+bool CompositionRootAutomationProvider::WasPropertyAdvised(PROPERTYID prop) noexcept {
+  return std::any_of(m_advisedProperties.begin(), m_advisedProperties.end(), [prop](const AdvisedEvent &ae) {
+    return ae.Property == prop && ae.Count > 0;
+  });
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -13,7 +13,8 @@ class CompositionRootAutomationProvider : public winrt::implements<
                                               IInspectable,
                                               IRawElementProviderFragmentRoot,
                                               IRawElementProviderFragment,
-                                              IRawElementProviderSimple> {
+                                              IRawElementProviderSimple,
+                                              IRawElementProviderAdviseEvents> {
  public:
   // inherited via IRawElementProviderFragmentRoot
   virtual HRESULT __stdcall ElementProviderFromPoint(double x, double y, IRawElementProviderFragment **pRetVal)
@@ -34,13 +35,47 @@ class CompositionRootAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) override;
   virtual HRESULT __stdcall get_HostRawElementProvider(IRawElementProviderSimple **pRetVal) override;
 
+  // IRawElementProviderAdviseEvents
+  virtual HRESULT __stdcall AdviseEventAdded(EVENTID idEvent, SAFEARRAY *psaProperties) override;
+  virtual HRESULT __stdcall AdviseEventRemoved(EVENTID idEvent, SAFEARRAY *psaProperties) override;
+
   CompositionRootAutomationProvider(
       const std::shared_ptr<::Microsoft::ReactNative::RootComponentView> &componentView) noexcept;
+
   void SetHwnd(HWND hwnd) noexcept;
+#ifdef USE_WINUI3
+  void SetIsland(winrt::Microsoft::UI::Content::ContentIsland &island) noexcept;
+#endif
+  bool WasPropertyAdvised(PROPERTYID prop) noexcept;
+  bool WasEventAdvised(EVENTID event) noexcept;
+
+  // It's unlikely for the underlying primitive types for EVENTID and PROPERTYID to ever change, but let's make sure
+  static_assert(std::is_same<EVENTID, PROPERTYID>::value);
+  // Helper class for AdviseEventAdded/Removed. I could've simply used a std::pair, but I find using structs with named
+  // members easier to read and more self-documenting than pair.first and pair.last. Since this is simply syntactic
+  // sugar, I'm leveraging the fact that both EVENTID and PROPERTYID are ints under the hood to share
+  // AdviseEventAddedImpl
+  struct AdvisedEvent {
+    union {
+      EVENTID Event;
+      PROPERTYID Property;
+    };
+    uint32_t Count;
+  };
 
  private:
+  HRESULT AdvisePropertiesAdded(SAFEARRAY *psaProperties) noexcept;
+  HRESULT AdvisePropertiesRemoved(SAFEARRAY *psaProperties) noexcept;
+
+  // Linear search on unsorted vectors is typically faster than more sophisticated data structures when N is small. In
+  // practice ATs tend to only listen to a dozen or so props and events, so std::vector is likely better than maps.
+  std::vector<AdvisedEvent> m_advisedEvents{};
+  std::vector<AdvisedEvent> m_advisedProperties{};
   ::Microsoft::ReactNative::ReactTaggedView m_view;
   HWND m_hwnd{nullptr};
+#ifdef USE_WINUI3
+  winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};
+#endif
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -21,6 +21,11 @@
 #include "ReactNativeHost.h"
 #include "RootComponentView.h"
 
+#ifdef USE_WINUI3
+#include <winrt/Microsoft.UI.Content.h>
+#include "CompositionRootAutomationProvider.h"
+#endif
+
 namespace winrt::Microsoft::ReactNative::implementation {
 
 //! This class ensures that we access ReactRootView from UI thread.
@@ -98,6 +103,11 @@ inline Mso::Future<void> CompositionReactViewInstance::PostInUIQueue(TAction &&a
 
 CompositionRootView::CompositionRootView() noexcept {}
 
+#ifdef USE_WINUI3
+CompositionRootView::CompositionRootView(winrt::Microsoft::UI::Composition::Compositor compositor) noexcept
+    : m_compositor(compositor) {}
+#endif
+
 ReactNative::IReactViewHost CompositionRootView::ReactViewHost() noexcept {
   return m_reactViewHost;
 }
@@ -138,11 +148,11 @@ void CompositionRootView::Size(winrt::Windows::Foundation::Size value) noexcept
   m_size = value;
 }
 
-double CompositionRootView::ScaleFactor() noexcept {
+float CompositionRootView::ScaleFactor() noexcept {
   return m_scaleFactor;
 }
 
-void CompositionRootView::ScaleFactor(double value) noexcept {
+void CompositionRootView::ScaleFactor(float value) noexcept {
   m_scaleFactor = value;
 }
 
@@ -191,15 +201,6 @@ int64_t CompositionRootView::SendMessage(uint32_t msg, uint64_t wParam, int64_t
   return 0;
 }
 
-void CompositionRootView::OnScrollWheel(Windows::Foundation::Point point, int32_t delta) noexcept {
-  if (m_rootTag == -1)
-    return;
-
-  if (m_CompositionEventHandler) {
-    m_CompositionEventHandler->ScrollWheel({point.X, point.Y}, delta);
-  }
-}
-
 void CompositionRootView::InitRootView(
     winrt::Microsoft::ReactNative::IReactContext &&context,
     winrt::Microsoft::ReactNative::ReactViewOptions &&viewOptions) noexcept {
@@ -303,8 +304,9 @@ void CompositionRootView::ShowInstanceLoading() noexcept {
   // TODO: Show loading UI here
 }
 
-Windows::Foundation::Size CompositionRootView::Measure(Windows::Foundation::Size const &availableSize) const {
-  Windows::Foundation::Size size{0.0f, 0.0f};
+winrt::Windows::Foundation::Size CompositionRootView::Measure(
+    winrt::Windows::Foundation::Size const &availableSize) const {
+  winrt::Windows::Foundation::Size size{0.0f, 0.0f};
 
   if (m_isInitialized && m_rootTag != -1) {
     if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
@@ -336,7 +338,7 @@ Windows::Foundation::Size CompositionRootView::Measure(Windows::Foundation::Size
   return size;
 }
 
-Windows::Foundation::Size CompositionRootView::Arrange(Windows::Foundation::Size finalSize) const {
+winrt::Windows::Foundation::Size CompositionRootView::Arrange(winrt::Windows::Foundation::Size finalSize) const {
   if (m_isInitialized && m_rootTag != -1) {
     if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
             winrt::Microsoft::ReactNative::ReactPropertyBag(m_context.Properties()))) {
@@ -364,7 +366,42 @@ Windows::Foundation::Size CompositionRootView::Arrange(Windows::Foundation::Size
   return finalSize;
 }
 
+#ifdef USE_WINUI3
+winrt::Microsoft::UI::Content::ContentIsland CompositionRootView::Island() noexcept {
+  if (!m_compositor) {
+    return nullptr;
+  }
+
+  if (!m_island) {
+    auto rootVisual = m_compositor.CreateSpriteVisual();
+    rootVisual.RelativeSizeAdjustment({1, 1});
+
+    RootVisual(winrt::Microsoft::ReactNative::Composition::MicrosoftCompositionContextHelper::CreateVisual(rootVisual));
+    m_island = winrt::Microsoft::UI::Content::ContentIsland::Create(rootVisual);
+
+    m_island.AutomationProviderRequested(
+        [this](
+            winrt::Microsoft::UI::Content::ContentIsland const &,
+            winrt::Microsoft::UI::Content::ContentIslandAutomationProviderRequestedEventArgs const &args) {
+          auto provider = GetUiaProvider();
+          auto pRootProvider =
+              static_cast<winrt::Microsoft::ReactNative::implementation::CompositionRootAutomationProvider *>(
+                  provider.as<IRawElementProviderSimple>().get());
+          if (pRootProvider != nullptr) {
+            pRootProvider->SetIsland(m_island);
+          }
+          args.AutomationProvider(std::move(provider));
+          args.Handled(true);
+        });
+  }
+  return m_island;
+}
+#endif
+
 ::Microsoft::ReactNative::RootComponentView *CompositionRootView::GetComponentView() noexcept {
+  if (!m_context || m_context.Handle().LoadingState() != winrt::Microsoft::ReactNative::LoadingState::Loaded)
+    return nullptr;
+
   if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
           winrt::Microsoft::ReactNative::ReactPropertyBag(m_context.Properties()))) {
     auto rootComponentViewDescriptor = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(