Add basic UIA provider to Fabric's CompositionRootView (#11129)

* commit to diff against main

* yarn format

* unintentional formatting changes

* clean up test code

* removing lines from bad merge

* Change files

* fix build break in desktop

Author: FalseLobster

change/react-native-windows-601c7088-6021-4533-b2b7-82d0ec2a36ba.json

@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Add root UIA provider",
+  "packageName": "react-native-windows",
+  "email": "adrum@microsoft.com",
+  "dependentChangeType": "patch"
+}

packages/playground/windows/playground-composition/Playground-Composition.cpp

@@ -14,6 +14,7 @@
 #include "../../../../vnext/codegen/NativeDeviceInfoSpec.g.h"
 
 #include <DispatcherQueue.h>
+#include <UIAutomation.h>
 #include <windows.ui.composition.interop.h>
 
 #include <winrt/Microsoft.ReactNative.Composition.h>
@@ -351,6 +352,19 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
       SetProp(hwnd, WindowDataProperty, reinterpret_cast<HANDLE>(windowData));
       break;
     }
+    case WM_GETOBJECT: {
+      if (lparam == UiaRootObjectId) {
+        auto windowData = WindowData::GetFromWindow(hwnd);
+        if (!windowData->m_windowInited)
+          break;
+
+        auto hwndHost = windowData->m_CompositionHwndHost;
+        winrt::com_ptr<IRawElementProviderSimple> spReps;
+        hwndHost.UiaProvider().as(spReps);
+        LRESULT lResult = UiaReturnRawElementProvider(hwnd, wparam, lparam, spReps.get());
+        return lResult;
+      }
+    }
   }
 
   return DefWindowProc(hwnd, message, wparam, lparam);

vnext/Microsoft.ReactNative/CompositionHwndHost.idl

@@ -28,6 +28,8 @@ namespace Microsoft.ReactNative
     IReactViewHost ReactViewHost { get; set; };
 
     Int64 TranslateMessage(UInt32 msg, UInt64 wParam, Int64 lParam);
+
+    Object UiaProvider { get; };
   }
 
-} // namespace Microsoft.ReactNative
+} // namespace Microsoft.ReactNative

vnext/Microsoft.ReactNative/CompositionRootView.idl

@@ -37,6 +37,8 @@ namespace Microsoft.ReactNative
 
     Int64 SendMessage(UInt32 Msg, UInt64 WParam, Int64 LParam);
 
+    Object GetUiaProvider(UInt64 hwnd);
+
     //void OnPointerPressed(PointerPressedArgs args);
     //void OnMouseUp(Windows.Foundation.Point point);
     void OnScrollWheel(Windows.Foundation.Point point, Int32 delta);

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

@@ -14,6 +14,8 @@
 #include "CompositionContextHelper.h"
 #include "ReactNativeHost.h"
 
+#include "CompositionRootView.h"
+
 WINUSERAPI UINT WINAPI GetDpiForWindow(_In_ HWND hwnd);
 
 namespace winrt::Microsoft::ReactNative::implementation {
@@ -142,4 +144,9 @@ winrt::Windows::UI::Composition::Compositor CompositionHwndHost::Compositor() co
       compositionContext);
 }
 
+IInspectable CompositionHwndHost::UiaProvider() noexcept {
+  auto compRootView = winrt::get_self<implementation::CompositionRootView>(m_compRootView);
+  return compRootView->GetUiaProvider(reinterpret_cast<uint64_t>(m_hwnd));
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -20,6 +20,9 @@ struct CompositionHwndHost : CompositionHwndHostT<CompositionHwndHost> {
   winrt::Microsoft::ReactNative::IReactViewHost ReactViewHost() const noexcept;
   void ReactViewHost(winrt::Microsoft::ReactNative::IReactViewHost const &value) noexcept;
 
+  // property UiaProvider
+  IInspectable UiaProvider() noexcept;
+
   winrt::Windows::UI::Composition::Visual RootVisual() const noexcept;
 
   LRESULT TranslateMessage(int msg, uint64_t wParam, int64_t lParam) noexcept;

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

@@ -0,0 +1,125 @@
+#include "pch.h"
+#include "CompositionRootAutomationProvider.h"
+
+#include "Fabric/Composition/CompositionRootView.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionRootAutomationProvider::CompositionRootAutomationProvider(
+    winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::CompositionRootView> &&weakRootControl,
+    HWND hwnd) noexcept
+    : m_weakRootControl{std::move(weakRootControl)}, m_hwnd{hwnd} {}
+
+// Implementations should return NULL for a top-level element that is hosted in a window. Other elements should return
+// an array that contains UiaAppendRuntimeId (defined in Uiautomationcoreapi.h), followed by a value that is unique
+// within an instance of the fragment.
+//
+// We'll use the View pointer as our identifier for those situations
+HRESULT __stdcall CompositionRootAutomationProvider::GetRuntimeId(SAFEARRAY **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::GetEmbeddedFragmentRoots(SAFEARRAY **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::SetFocus(void) {
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::get_HostRawElementProvider(IRawElementProviderSimple **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  if (!IsWindow(m_hwnd))
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto hr = UiaHostProviderFromHwnd(m_hwnd, pRetVal);
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::get_BoundingRectangle(UiaRect *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  AddRef();
+  *pRetVal = this;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::get_ProviderOptions(ProviderOptions *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = ProviderOptions_ServerSideProvider | ProviderOptions_UseComThreading;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::ElementProviderFromPoint(
+    double x,
+    double y,
+    IRawElementProviderFragment **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::GetFocus(IRawElementProviderFragment **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
+    NavigateDirection direction,
+    IRawElementProviderFragment **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  *pRetVal = nullptr;
+
+  return S_OK;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <UIAutomation.h>
+#include <inspectable.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+struct CompositionRootView;
+
+class CompositionRootAutomationProvider : public winrt::implements<
+                                              CompositionRootAutomationProvider,
+                                              IInspectable,
+                                              IRawElementProviderFragmentRoot,
+                                              IRawElementProviderFragment,
+                                              IRawElementProviderSimple> {
+ public:
+  // inherited via IRawElementProviderFragmentRoot
+  virtual HRESULT __stdcall ElementProviderFromPoint(double x, double y, IRawElementProviderFragment **pRetVal)
+      override;
+  virtual HRESULT __stdcall GetFocus(IRawElementProviderFragment **pRetVal) override;
+
+  // inherited via IRawElementProviderFragment
+  virtual HRESULT __stdcall Navigate(NavigateDirection direction, IRawElementProviderFragment **pRetVal) override;
+  virtual HRESULT __stdcall GetRuntimeId(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall get_BoundingRectangle(UiaRect *pRetVal) override;
+  virtual HRESULT __stdcall GetEmbeddedFragmentRoots(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall SetFocus(void) override;
+  virtual HRESULT __stdcall get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal) override;
+
+  // inherited via IRawElementProviderSimple
+  virtual HRESULT __stdcall get_ProviderOptions(ProviderOptions *pRetVal) override;
+  virtual HRESULT __stdcall GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) override;
+  virtual HRESULT __stdcall GetPropertyValue(PROPERTYID propertyId, VARIANT *pRetVal) override;
+  virtual HRESULT __stdcall get_HostRawElementProvider(IRawElementProviderSimple **pRetVal) override;
+
+  CompositionRootAutomationProvider(
+      winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::CompositionRootView> &&weakRootControl,
+      HWND hwnd) noexcept;
+
+ private:
+  winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::CompositionRootView> m_weakRootControl;
+  HWND m_hwnd;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -144,6 +144,14 @@ void CompositionRootView::ScaleFactor(double value) noexcept {
   m_scaleFactor = value;
 }
 
+IInspectable CompositionRootView::GetUiaProvider(uint64_t hwnd) noexcept {
+  if (m_compositionUiaProvider == nullptr) {
+    m_compositionUiaProvider =
+        winrt::make<CompositionRootAutomationProvider>(this->get_weak(), reinterpret_cast<HWND>(hwnd));
+  }
+  return m_compositionUiaProvider;
+}
+
 winrt::Microsoft::ReactNative::Composition::IVisual CompositionRootView::GetVisual() const noexcept {
   return m_rootVisual;
 }

vnext/Microsoft.ReactNative/Fabric/Composition/CompositionRootView.h

@@ -7,6 +7,7 @@
 #include <ReactContext.h>
 #include <winrt/Microsoft.ReactNative.h>
 #include "CompositionEventHandler.h"
+#include "CompositionRootAutomationProvider.h"
 #include "ReactHost/React.h"
 #include "Views/ICompositionRootView.h"
 
@@ -34,6 +35,8 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
   Windows::Foundation::Size Measure(Windows::Foundation::Size const &availableSize) const;
   Windows::Foundation::Size Arrange(Windows::Foundation::Size finalSize) const;
 
+  IInspectable GetUiaProvider(uint64_t hWnd) noexcept;
+
   int64_t SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept;
   void OnScrollWheel(Windows::Foundation::Point point, int32_t delta) noexcept;
 
@@ -55,6 +58,7 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
   void UninitRootView() noexcept;
 
  private:
+  IInspectable m_compositionUiaProvider{nullptr};
   bool m_isInitialized{false};
   bool m_isJSViewAttached{false};
   IReactDispatcher m_uiDispatcher{nullptr};