react-native-windows 0.71.10 → 0.72.0-preview.2

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

@@ -0,0 +1,147 @@
+#include "pch.h"
+#include "CompositionRootAutomationProvider.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionRootAutomationProvider::CompositionRootAutomationProvider(
+    const std::shared_ptr<::Microsoft::ReactNative::RootComponentView> &componentView) noexcept
+    : m_view{componentView} {}
+
+// 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 react tag 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;
+
+  auto strongView = m_view.view();
+
+  if (strongView == nullptr) {
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  }
+
+  auto rootCV = std::static_pointer_cast<::Microsoft::ReactNative::RootComponentView>(strongView);
+  auto focusedComponent = rootCV->GetFocusedComponent();
+
+  if (focusedComponent) {
+    auto focusedUiaProvider = focusedComponent->EnsureUiaProvider();
+    winrt::com_ptr<IRawElementProviderFragment> spFragment;
+    focusedUiaProvider.as(spFragment);
+    *pRetVal = spFragment.detach();
+  }
+
+  return S_OK;
+}
+
+void CompositionRootAutomationProvider::SetHwnd(HWND hwnd) noexcept {
+  m_hwnd = hwnd;
+}
+
+HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
+    NavigateDirection direction,
+    IRawElementProviderFragment **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+
+  // Fragment roots do not enable navigation to a parent or siblings; navigation among fragment roots is handled by the
+  // default window providers. Elements in fragments must navigate only to other elements within that fragment.
+  if (direction == NavigateDirection_FirstChild || direction == NavigateDirection_LastChild) {
+    return UiaNavigateHelper(m_view, direction, *pRetVal);
+  }
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <Fabric/Composition/RootComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#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(
+      const std::shared_ptr<::Microsoft::ReactNative::RootComponentView> &componentView) noexcept;
+  void SetHwnd(HWND hwnd) noexcept;
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  HWND m_hwnd{nullptr};
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -3,6 +3,7 @@
 #include "pch.h"
 #include "CompositionRootView.h"
 #include "CompositionRootView.g.cpp"
+#include "FocusNavigationRequest.g.cpp"
 
 #include <DynamicWriter.h>
 #include <Fabric/FabricUIManagerModule.h>
@@ -18,6 +19,7 @@
 #include "CompositionContextHelper.h"
 #include "CompositionHelpers.h"
 #include "ReactNativeHost.h"
+#include "RootComponentView.h"
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
@@ -144,6 +146,14 @@ void CompositionRootView::ScaleFactor(double value) noexcept {
   m_scaleFactor = value;
 }
 
+winrt::IInspectable CompositionRootView::GetUiaProvider() noexcept {
+  auto componentView = GetComponentView();
+  if (componentView == nullptr)
+    return nullptr;
+
+  return componentView->EnsureUiaProvider();
+}
+
 winrt::Microsoft::ReactNative::Composition::IVisual CompositionRootView::GetVisual() const noexcept {
   return m_rootVisual;
 }
@@ -173,8 +183,7 @@ int64_t CompositionRootView::SendMessage(uint32_t msg, uint64_t wParam, int64_t
     return 0;
 
   if (m_CompositionEventHandler) {
-    auto result =
-        m_CompositionEventHandler->SendMessage(static_cast<facebook::react::SurfaceId>(m_rootTag), msg, wParam, lParam);
+    auto result = m_CompositionEventHandler->SendMessage(msg, wParam, lParam);
     if (result)
       return result;
   }
@@ -187,8 +196,7 @@ void CompositionRootView::OnScrollWheel(Windows::Foundation::Point point, int32_
     return;
 
   if (m_CompositionEventHandler) {
-    m_CompositionEventHandler->ScrollWheel(
-        static_cast<facebook::react::SurfaceId>(m_rootTag), {point.X, point.Y}, delta);
+    m_CompositionEventHandler->ScrollWheel({point.X, point.Y}, delta);
   }
 }
 
@@ -356,4 +364,23 @@ Windows::Foundation::Size CompositionRootView::Arrange(Windows::Foundation::Size
   return finalSize;
 }
 
+::Microsoft::ReactNative::RootComponentView *CompositionRootView::GetComponentView() noexcept {
+  if (auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
+          winrt::Microsoft::ReactNative::ReactPropertyBag(m_context.Properties()))) {
+    auto rootComponentViewDescriptor = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(
+        static_cast<facebook::react::SurfaceId>(m_rootTag));
+    return static_cast<::Microsoft::ReactNative::RootComponentView *>(rootComponentViewDescriptor.view.get());
+  }
+  return nullptr;
+}
+
+winrt::Microsoft::ReactNative::FocusNavigationResult CompositionRootView::NavigateFocus(
+    const winrt::Microsoft::ReactNative::FocusNavigationRequest &request) noexcept {
+  if (auto view = GetComponentView()) {
+    return winrt::make<winrt::Microsoft::ReactNative::implementation::FocusNavigationResult>(
+        view->NavigateFocus(request));
+  }
+  return winrt::make<winrt::Microsoft::ReactNative::implementation::FocusNavigationResult>(false);
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -3,6 +3,8 @@
 #pragma once
 
 #include "CompositionRootView.g.h"
+#include <FocusNavigationRequest.g.h>
+#include <FocusNavigationResult.g.h>
 
 #include <ReactContext.h>
 #include <winrt/Microsoft.ReactNative.h>
@@ -12,6 +14,32 @@
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
+struct FocusNavigationRequest : FocusNavigationRequestT<FocusNavigationRequest> {
+  FocusNavigationRequest(winrt::Microsoft::ReactNative::FocusNavigationReason reason) : m_reason(reason) {}
+
+  winrt::Microsoft::ReactNative::FocusNavigationReason Reason() noexcept {
+    return m_reason;
+  }
+
+  void Reason(winrt::Microsoft::ReactNative::FocusNavigationReason reason) noexcept {
+    m_reason = reason;
+  }
+
+ private:
+  winrt::Microsoft::ReactNative::FocusNavigationReason m_reason;
+};
+
+struct FocusNavigationResult : FocusNavigationResultT<FocusNavigationResult> {
+  FocusNavigationResult(bool wasFocusMoved) : m_wasFocusMoved(wasFocusMoved) {}
+
+  bool WasFocusMoved() noexcept {
+    return m_wasFocusMoved;
+  }
+
+ private:
+  const bool m_wasFocusMoved;
+};
+
 struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Microsoft::ReactNative::ICompositionRootView {
   CompositionRootView() noexcept;
 
@@ -34,6 +62,13 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
   Windows::Foundation::Size Measure(Windows::Foundation::Size const &availableSize) const;
   Windows::Foundation::Size Arrange(Windows::Foundation::Size finalSize) const;
 
+  winrt::Microsoft::ReactNative::FocusNavigationResult NavigateFocus(
+      const winrt::Microsoft::ReactNative::FocusNavigationRequest &request) noexcept;
+
+  ::Microsoft::ReactNative::RootComponentView *GetComponentView() noexcept;
+
+  IInspectable GetUiaProvider() noexcept;
+
   int64_t SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept;
   void OnScrollWheel(Windows::Foundation::Point point, int32_t delta) noexcept;
 
@@ -78,4 +113,6 @@ struct CompositionRootView : CompositionRootViewT<CompositionRootView>, ::Micros
 
 namespace winrt::Microsoft::ReactNative::factory_implementation {
 struct CompositionRootView : CompositionRootViewT<CompositionRootView, implementation::CompositionRootView> {};
+struct FocusNavigationRequest
+    : FocusNavigationRequestT<FocusNavigationRequest, implementation::FocusNavigationRequest> {};
 } // namespace winrt::Microsoft::ReactNative::factory_implementation