react-native-windows 0.69.4 → 0.70.0-preview.1

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.cpp

@@ -6,14 +6,17 @@
 #include <DynamicWriter.h>
 #include <IReactContext.h>
 #include <IReactRootView.h>
+#include <Modules/NativeUIManager.h>
 #include <Modules/PaperUIManagerModule.h>
-#include <Modules\NativeUIManager.h>
 #include <Views/ViewManager.h>
 #include <XamlUtils.h>
+#include <cxxreact/SystraceSection.h>
 #include "ShadowNodeBase.h"
 #include "Unicode.h"
 #include "XamlUIService.h"
 
+using namespace facebook::react;
+
 namespace Microsoft::ReactNative {
 
 struct ViewAtIndex final {
@@ -126,20 +129,24 @@ class UIManagerModule : public std::enable_shared_from_this<UIManagerModule>, pu
 
   void createView(int64_t reactTag, std::string viewName, int64_t rootTag, React::JSValueObject &&props) noexcept {
     m_nativeUIManager->ensureInBatch();
-    auto viewManager = GetViewManager(viewName);
-    auto node = viewManager->createShadow();
-    node->m_className = std::move(viewName);
-    node->m_tag = reactTag;
-    node->m_rootTag = rootTag;
-    node->m_viewManager = viewManager;
+    if (auto viewManager = GetViewManager(viewName)) {
+      auto node = viewManager->createShadow();
+      node->m_className = std::move(viewName);
+      node->m_tag = reactTag;
+      node->m_rootTag = rootTag;
+      node->m_viewManager = viewManager;
 
-    node->createView(props);
+      node->createView(props);
 
-    m_nativeUIManager->CreateView(*node, props);
+      m_nativeUIManager->CreateView(*node, props);
 
-    m_nodeRegistry.addNode(shadow_ptr(node), reactTag);
+      m_nodeRegistry.addNode(shadow_ptr(node), reactTag);
 
-    node->updateProperties(props);
+      node->updateProperties(props);
+    } else {
+      assert(false);
+      return;
+    }
   }
 
   void updateView(int64_t reactTag, std::string viewName, React::JSValueObject &&props) noexcept {
@@ -578,6 +585,7 @@ void UIManager::createView(
                                                          viewName = std::move(viewName),
                                                          rootTag,
                                                          props = std::move(props)]() mutable {
+    SystraceSection s("UIManager::createView");
     if (auto module = m.lock()) {
       module->createView(static_cast<int64_t>(reactTag), viewName, static_cast<int64_t>(rootTag), std::move(props));
     }
@@ -589,6 +597,7 @@ void UIManager::updateView(double reactTag, std::string viewName, React::JSValue
                                                          reactTag,
                                                          viewName = std::move(viewName),
                                                          props = std::move(props)]() mutable {
+    SystraceSection s("UIManager::updateView");
     if (auto module = m.lock()) {
       module->updateView(static_cast<int64_t>(reactTag), viewName, std::move(props));
     }
@@ -597,6 +606,7 @@ void UIManager::updateView(double reactTag, std::string viewName, React::JSValue
 
 void UIManager::focus(double reactTag) noexcept {
   m_batchingUIMessageQueue->runOnQueue([m = std::weak_ptr<UIManagerModule>(m_module), reactTag]() {
+    SystraceSection s("UIManager::focus");
     if (auto module = m.lock()) {
       module->focus(static_cast<int64_t>(reactTag));
     }
@@ -605,6 +615,7 @@ void UIManager::focus(double reactTag) noexcept {
 
 void UIManager::blur(double reactTag) noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), reactTag]() {
+    SystraceSection s("UIManager::blur");
     if (auto module = m.lock()) {
       module->blur(static_cast<int64_t>(reactTag));
     }
@@ -620,6 +631,7 @@ void UIManager::findSubviewIn(
                                                          reactTag,
                                                          point = std::move(point),
                                                          callback = std::move(callback)]() mutable {
+    SystraceSection s("UIManager::findSubviewIn");
     if (auto module = m.lock()) {
       module->findSubviewIn(static_cast<int64_t>(reactTag), std::move(point), std::move(callback));
     }
@@ -634,6 +646,7 @@ void UIManager::dispatchViewManagerCommand(
                                                          reactTag,
                                                          commandID = std::move(commandID),
                                                          commandArgs = std::move(commandArgs)]() mutable {
+    SystraceSection s("UIManager::dispatchViewManagerCommand");
     if (auto module = m.lock()) {
       module->dispatchViewManagerCommand(static_cast<int64_t>(reactTag), std::move(commandID), std::move(commandArgs));
     }
@@ -646,6 +659,7 @@ void UIManager::measure(
         &callback) noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor(
       [m = std::weak_ptr<UIManagerModule>(m_module), reactTag, callback = std::move(callback)]() mutable {
+        SystraceSection s("UIManager::measure");
         if (auto module = m.lock()) {
           module->measure(static_cast<int64_t>(reactTag), std::move(callback));
         }
@@ -657,6 +671,7 @@ void UIManager::measureInWindow(
     std::function<void(double x, double y, double width, double height)> const &callback) noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor(
       [m = std::weak_ptr<UIManagerModule>(m_module), reactTag, callback = std::move(callback)]() mutable {
+        SystraceSection s("UIManager::measureInWindow");
         if (auto module = m.lock()) {
           module->measureInWindow(static_cast<int64_t>(reactTag), std::move(callback));
         }
@@ -671,6 +686,7 @@ void UIManager::viewIsDescendantOf(
                                                          reactTag,
                                                          ancestorReactTag,
                                                          callback = std::move(callback)]() mutable {
+    SystraceSection s("UIManager::viewIsDescendantOf");
     if (auto module = m.lock()) {
       module->viewIsDescendantOf(
           static_cast<int64_t>(reactTag), static_cast<int64_t>(ancestorReactTag), std::move(callback));
@@ -688,6 +704,7 @@ void UIManager::measureLayout(
                                                          ancestorReactTag,
                                                          errorCallback = std::move(errorCallback),
                                                          callback = std::move(callback)]() mutable {
+    SystraceSection s("UIManager::measureLayout");
     if (auto module = m.lock()) {
       module->measureLayout(
           static_cast<int64_t>(reactTag),
@@ -706,6 +723,7 @@ void UIManager::measureLayoutRelativeToParent(
                                                          reactTag,
                                                          errorCallback = std::move(errorCallback),
                                                          callback = std::move(callback)]() mutable {
+    SystraceSection s("UIManager::measureLayoutRelativeToParent");
     if (auto module = m.lock()) {
       module->measureLayoutRelativeToParent(
           static_cast<int64_t>(reactTag), std::move(errorCallback), std::move(callback));
@@ -716,6 +734,7 @@ void UIManager::measureLayoutRelativeToParent(
 void UIManager::setJSResponder(double reactTag, bool blockNativeResponder) noexcept {
   m_batchingUIMessageQueue->runOnQueue(
       Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), reactTag, blockNativeResponder]() mutable {
+        SystraceSection s("UIManager::setJSResponder");
         if (auto module = m.lock()) {
           module->setJSResponder(static_cast<int64_t>(reactTag), blockNativeResponder);
         }
@@ -724,6 +743,7 @@ void UIManager::setJSResponder(double reactTag, bool blockNativeResponder) noexc
 
 void UIManager::clearJSResponder() noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module)]() mutable {
+    SystraceSection s("UIManager::clearJSResponder");
     if (auto module = m.lock()) {
       module->clearJSResponder();
     }
@@ -738,6 +758,7 @@ void UIManager::configureNextLayoutAnimation(
                                                          config = std::move(config),
                                                          callback = std::move(callback),
                                                          errorCallback = std::move(errorCallback)]() mutable {
+    SystraceSection s("UIManager::configureNextLayoutAnimation");
     if (auto module = m.lock()) {
       module->configureNextLayoutAnimation(std::move(config), std::move(callback), std::move(errorCallback));
     }
@@ -746,6 +767,7 @@ void UIManager::configureNextLayoutAnimation(
 
 void UIManager::removeSubviewsFromContainerWithID(double containerID) noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), containerID]() {
+    SystraceSection s("UIManager::removeSubviewsFromContainerWithID");
     if (auto module = m.lock()) {
       module->removeSubviewsFromContainerWithID(static_cast<int64_t>(containerID));
     }
@@ -755,6 +777,7 @@ void UIManager::removeSubviewsFromContainerWithID(double containerID) noexcept {
 void UIManager::replaceExistingNonRootView(double reactTag, double newReactTag) noexcept {
   m_batchingUIMessageQueue->runOnQueue(
       Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), reactTag, newReactTag]() {
+        SystraceSection s("UIManager::replaceExistingNonRootView");
         if (auto module = m.lock()) {
           module->replaceExistingNonRootView(static_cast<int64_t>(reactTag), static_cast<int64_t>(newReactTag));
         }
@@ -763,6 +786,7 @@ void UIManager::replaceExistingNonRootView(double reactTag, double newReactTag)
 
 void UIManager::removeRootView(double reactTag) noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), reactTag]() {
+    SystraceSection s("UIManager::removeRootView");
     if (auto module = m.lock()) {
       module->removeRootView(static_cast<int64_t>(reactTag));
     }
@@ -772,6 +796,7 @@ void UIManager::removeRootView(double reactTag) noexcept {
 void UIManager::setChildren(double containerTag, React::JSValueArray &&reactTags) noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor(
       [m = std::weak_ptr<UIManagerModule>(m_module), containerTag, reactTags = std::move(reactTags)]() mutable {
+        SystraceSection s("UIManager::setChildren");
         if (auto module = m.lock()) {
           module->setChildren(static_cast<int64_t>(containerTag), std::move(reactTags));
         }
@@ -792,6 +817,7 @@ void UIManager::manageChildren(
                                                          addChildReactTags = std::move(addChildReactTags),
                                                          addAtIndices = std::move(addAtIndices),
                                                          removeAtIndices = std::move(removeAtIndices)]() mutable {
+    SystraceSection s("UIManager::manageChildren");
     if (auto module = m.lock()) {
       module->manageChildren(
           static_cast<int64_t>(containerTag),
@@ -807,6 +833,7 @@ void UIManager::manageChildren(
 void UIManager::setLayoutAnimationEnabledExperimental(bool enabled) noexcept {
   m_batchingUIMessageQueue->runOnQueue(
       Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), enabled]() mutable {
+        SystraceSection s("UIManager::setLayoutAnimationEnabledExperimental");
         if (auto module = m.lock()) {
           module->setLayoutAnimationEnabledExperimental(enabled);
         }
@@ -816,6 +843,7 @@ void UIManager::setLayoutAnimationEnabledExperimental(bool enabled) noexcept {
 void UIManager::sendAccessibilityEvent(double reactTag, double eventType) noexcept {
   m_batchingUIMessageQueue->runOnQueue(
       Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module), reactTag, eventType]() mutable {
+        SystraceSection s("UIManager::sendAccessibilityEvent");
         if (auto module = m.lock()) {
           module->sendAccessibilityEvent(static_cast<int64_t>(reactTag), eventType);
         }
@@ -832,6 +860,7 @@ void UIManager::showPopupMenu(
                                                          items = std::move(items),
                                                          error = std::move(error),
                                                          success = std::move(success)]() mutable {
+    SystraceSection s("UIManager::showPopupMenu");
     if (auto module = m.lock()) {
       module->showPopupMenu(static_cast<int64_t>(reactTag), std::move(items), std::move(error), std::move(success));
     }
@@ -840,6 +869,7 @@ void UIManager::showPopupMenu(
 
 void UIManager::dismissPopupMenu() noexcept {
   m_batchingUIMessageQueue->runOnQueue(Mso::VoidFunctor([m = std::weak_ptr<UIManagerModule>(m_module)]() mutable {
+    SystraceSection s("UIManager::dismissPopupMenu");
     if (auto module = m.lock()) {
       module->dismissPopupMenu();
     }

package/Microsoft.ReactNative/Modules/PaperUIManagerModule.h

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 #pragma once
 
-#include "../../codegen/NativeUIManagerSpec.g.h"
+#include "codegen/NativeUIManagerSpec.g.h"
 #include <CxxMessageQueue.h>
 #include <INativeUIManager.h>
 #include <NativeModules.h>

package/Microsoft.ReactNative/QuirkSettings.cpp

@@ -40,6 +40,18 @@ EnableBackHandlerKindProperty() noexcept {
   return propId;
 }
 
+winrt::Microsoft::ReactNative::ReactPropertyId<bool> MapWindowDeactivatedToAppStateInactiveProperty() noexcept {
+  static winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{
+      L"ReactNative.QuirkSettings", L"MapWindowDeactivatedToAppStateInactiveProperty"};
+  return propId;
+}
+
+/*static*/ void QuirkSettings::SetMapWindowDeactivatedToAppStateInactive(
+    winrt::Microsoft::ReactNative::ReactPropertyBag properties,
+    bool value) noexcept {
+  properties.Set(MapWindowDeactivatedToAppStateInactiveProperty(), value);
+}
+
 #pragma region IDL interface
 
 /*static*/ void QuirkSettings::SetMatchAndroidAndIOSStretchBehavior(
@@ -60,6 +72,12 @@ EnableBackHandlerKindProperty() noexcept {
   ReactPropertyBag(settings.Properties()).Set(EnableBackHandlerKindProperty(), kind);
 }
 
+/*static*/ void QuirkSettings::SetMapWindowDeactivatedToAppStateInactive(
+    winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+    bool value) noexcept {
+  SetMapWindowDeactivatedToAppStateInactive(ReactPropertyBag(settings.Properties()), value);
+}
+
 #pragma endregion IDL interface
 
 /*static*/ bool QuirkSettings::GetMatchAndroidAndIOSStretchBehavior(ReactPropertyBag properties) noexcept {
@@ -76,4 +94,8 @@ EnableBackHandlerKindProperty() noexcept {
       .value_or(winrt::Microsoft::ReactNative::BackNavigationHandlerKind::JavaScript);
 }
 
+/*static*/ bool QuirkSettings::GetMapWindowDeactivatedToAppStateInactive(ReactPropertyBag properties) noexcept {
+  return properties.Get(MapWindowDeactivatedToAppStateInactiveProperty()).value_or(false);
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/QuirkSettings.h

@@ -26,6 +26,12 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
 
   static bool GetEnableFabric(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
+  static void SetMapWindowDeactivatedToAppStateInactive(
+      winrt::Microsoft::ReactNative::ReactPropertyBag properties,
+      bool value) noexcept;
+  static bool GetMapWindowDeactivatedToAppStateInactive(
+      winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+
 #pragma region Public API - part of IDL interface
   static void SetMatchAndroidAndIOSStretchBehavior(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
@@ -35,6 +41,10 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static void SetBackHandlerKind(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
       winrt::Microsoft::ReactNative::BackNavigationHandlerKind kind) noexcept;
+
+  static void SetMapWindowDeactivatedToAppStateInactive(
+      winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+      bool value) noexcept;
 #pragma endregion Public API - part of IDL interface
 };
 

package/Microsoft.ReactNative/QuirkSettings.idl

@@ -39,5 +39,12 @@ namespace Microsoft.ReactNative
       "these events, including forwarding to JavaScript.  This will allow applications to handle back "
       "navigation in native code, but will prevent the `BackHandler` native module from receiving events.")
     static void SetBackHandlerKind(ReactInstanceSettings settings, BackNavigationHandlerKind kind);
+
+    DOC_STRING(
+      "By default `react-native-windows` will only track `active` and `background` `AppState`. "
+      "Setting this to true enables `react-native-windows` to also track `inactive` `AppState` which [maps closely to iOS.](https://reactnative.dev/docs/appstate)"
+      "`inactive` tracks the [Window.Activated Event](https://docs.microsoft.com/uwp/api/windows.ui.core.corewindow.activated) when the window is deactivated.")
+    DOC_DEFAULT("false")
+    static void SetMapWindowDeactivatedToAppStateInactive(ReactInstanceSettings settings, Boolean value);
   }
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/ReactApplication.cpp

@@ -114,6 +114,10 @@ void ReactApplication::OnLaunched(activation::LaunchActivatedEventArgs const &e_
       e_;
 #endif // USE_WINUI3
 
+  if (m_launched) {
+    m_launched({*this}, e);
+  }
+
   this->OnCreate(e);
 }
 
@@ -195,6 +199,10 @@ void ReactApplication::OnCreate(Windows::ApplicationModel::Activation::IActivate
   }
 
   Window::Current().Activate();
+
+  if (m_viewCreated) {
+    m_viewCreated({*this}, args);
+  }
 }
 
 /// <summary>
@@ -219,4 +227,40 @@ void ReactApplication::OnNavigationFailed(IInspectable const &, NavigationFailed
   throw hresult_error(E_FAIL, hstring(L"Failed to load Page ") + e.SourcePageType().Name);
 }
 
+void ReactApplication::LaunchedInternal(ReactApplication::AppLaunchedDelegate delegate) noexcept {
+  m_launched = delegate;
+}
+
+ReactApplication::AppLaunchedDelegate ReactApplication::LaunchedInternal() const noexcept {
+  return m_launched;
+}
+
+void ReactApplication::ViewCreatedInternal(ReactApplication::AppViewCreatedDelegate delegate) noexcept {
+  m_viewCreated = delegate;
+}
+
+ReactApplication::AppViewCreatedDelegate ReactApplication::ViewCreatedInternal() const noexcept {
+  return m_viewCreated;
+}
+
+void ReactApplication::PageNavigatedInternal(ReactApplication::AppPageNavigatedDelegate delegate) noexcept {
+  m_pageNavigated = delegate;
+}
+
+ReactApplication::AppPageNavigatedDelegate ReactApplication::PageNavigatedInternal() const noexcept {
+  return m_pageNavigated;
+}
+
+xaml::Markup::IXamlType ReactApplication::GetXamlType(winrt::hstring const &name) const {
+  return m_provider.GetXamlType(name);
+}
+
+xaml::Markup::IXamlType ReactApplication::GetXamlType(::winrt::Windows::UI::Xaml::Interop::TypeName const &type) const {
+  return m_provider.GetXamlType(type);
+}
+
+::winrt::com_array<xaml::Markup::XmlnsDefinition> ReactApplication::GetXmlnsDefinitions() const {
+  return m_provider.GetXmlnsDefinitions();
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/ReactApplication.h

@@ -5,6 +5,8 @@
 
 #include "ReactApplication.g.h"
 #include <CppWinRTIncludes.h>
+#include <UI.Xaml.Markup.h>
+#include <winrt/Microsoft.ReactNative.h>
 #include "ReactNativeHost.h"
 
 #ifdef USE_WINUI3
@@ -71,7 +73,7 @@ struct __declspec(empty_bases) NoDefaultCtorReactApplication_base :
   }
 };
 
-struct ReactApplication : NoDefaultCtorReactApplication_base<ReactApplication> {
+struct ReactApplication : NoDefaultCtorReactApplication_base<ReactApplication, xaml::Markup::IXamlMetadataProvider> {
  public: // ReactApplication ABI API
   ReactApplication();
   ReactApplication(IInspectable const &outer) noexcept;
@@ -89,17 +91,48 @@ struct ReactApplication : NoDefaultCtorReactApplication_base<ReactApplication> {
   hstring JavaScriptBundleFile() noexcept;
   void JavaScriptBundleFile(hstring const &value) noexcept;
 
- public:
   void OnActivated(Windows::ApplicationModel::Activation::IActivatedEventArgs const &e);
   void OnLaunched(activation::LaunchActivatedEventArgs const &e);
   void OnSuspending(IInspectable const &, Windows::ApplicationModel::SuspendingEventArgs const &);
   void OnNavigationFailed(IInspectable const &, xaml::Navigation::NavigationFailedEventArgs const &);
 
+  using AppLaunchedDelegate = winrt::delegate<void(
+      winrt::Microsoft::ReactNative::ReactApplication const &sender,
+      winrt::Windows::ApplicationModel::Activation::LaunchActivatedEventArgs const &args)>;
+
+  void LaunchedInternal(AppLaunchedDelegate delegate) noexcept;
+  AppLaunchedDelegate LaunchedInternal() const noexcept;
+
+  using AppViewCreatedDelegate =
+      winrt::delegate<void(winrt::Microsoft::ReactNative::ReactApplication const &sender, winrt::hstring const &args)>;
+
+  void ViewCreatedInternal(AppViewCreatedDelegate delegate) noexcept;
+
+  AppViewCreatedDelegate ViewCreatedInternal() const noexcept;
+
+  using AppPageNavigatedDelegate =
+      winrt::delegate<void(winrt::Microsoft::ReactNative::ReactApplication const &sender, ReactRootView const &view)>;
+
+  void PageNavigatedInternal(AppPageNavigatedDelegate delegate) noexcept;
+
+  AppPageNavigatedDelegate PageNavigatedInternal() const noexcept;
+
+  xaml::Markup::IXamlType GetXamlType(winrt::hstring const &name) const;
+
+  xaml::Markup::IXamlType GetXamlType(::winrt::Windows::UI::Xaml::Interop::TypeName const &type) const;
+  ::winrt::com_array<xaml::Markup::XmlnsDefinition> GetXmlnsDefinitions() const;
+
  private:
-  ReactNative::ReactInstanceSettings m_instanceSettings{nullptr};
-  ReactNative::ReactNativeHost m_host{nullptr};
+  winrt::Microsoft::ReactNative::ReactInstanceSettings m_instanceSettings{nullptr};
+  winrt::Microsoft::ReactNative::ReactNativeHost m_host{nullptr};
 
   void OnCreate(Windows::ApplicationModel::Activation::IActivatedEventArgs const &e);
+
+  AppLaunchedDelegate m_launched;
+  AppViewCreatedDelegate m_viewCreated;
+  AppPageNavigatedDelegate m_pageNavigated;
+
+  XamlMetaDataProvider m_provider;
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation
@@ -109,7 +142,9 @@ namespace winrt::Microsoft::ReactNative::factory_implementation {
 // Override the CreateInstance method to pass baseInterface to the ReactApplication constructor
 // to support correct COM aggregation that is need to inherit from the ReactApplication.
 struct ReactApplication : ReactApplicationT<ReactApplication, implementation::ReactApplication> {
-  auto CreateInstance(IInspectable const &baseInterface, IInspectable &innerInterface) {
+  auto CreateInstance(
+      winrt::Windows::Foundation::IInspectable const &baseInterface,
+      winrt::Windows::Foundation::IInspectable &innerInterface) {
     return impl::composable_factory<implementation::ReactApplication>::template CreateInstance<
         Microsoft::ReactNative::ReactApplication>(baseInterface, innerInterface, baseInterface);
   }

package/Microsoft.ReactNative/ReactHost/JSCallInvokerScheduler.cpp

@@ -12,6 +12,7 @@ namespace Mso {
 struct JSCallInvokerScheduler
     : Mso::UnknownObject<Mso::RefCountStrategy::WeakRef, IDispatchQueueScheduler, IJSCallInvokerQueueScheduler> {
   JSCallInvokerScheduler(
+      const Mso::DispatchQueueSettings &settings,
       std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
       Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
       Mso::Promise<void> &&whenQuit) noexcept;
@@ -45,12 +46,13 @@ std::shared_ptr<facebook::react::MessageQueueThread> JSCallInvokerScheduler::Get
 //=============================================================================
 
 JSCallInvokerScheduler::JSCallInvokerScheduler(
+    const Mso::DispatchQueueSettings &settings,
     std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
     Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
     Mso::Promise<void> &&whenQuit) noexcept
     : m_callInvoker(callInvoker) {
   m_jsMessageThread = std::make_shared<Mso::React::MessageDispatchQueue>(
-      Mso::DispatchQueue::MakeLooperQueue(), std::move(errorHandler), std::move(whenQuit));
+      Mso::DispatchQueue::MakeLooperQueue(settings), std::move(errorHandler), std::move(whenQuit));
 }
 
 JSCallInvokerScheduler::~JSCallInvokerScheduler() noexcept {
@@ -91,11 +93,12 @@ void JSCallInvokerScheduler::AwaitTermination() noexcept {
 }
 
 Mso::CntPtr<IDispatchQueueScheduler> MakeJSCallInvokerScheduler(
+    const Mso::DispatchQueueSettings &settings,
     std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
     Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
     Mso::Promise<void> &&whenQuit) noexcept {
   return Mso::Make<JSCallInvokerScheduler, IDispatchQueueScheduler>(
-      std::move(callInvoker), std::move(errorHandler), std::move(whenQuit));
+      settings, std::move(callInvoker), std::move(errorHandler), std::move(whenQuit));
 }
 
 } // namespace Mso

package/Microsoft.ReactNative/ReactHost/JSCallInvokerScheduler.h

@@ -19,6 +19,7 @@ struct IJSCallInvokerQueueScheduler : IUnknown {
 };
 
 Mso::CntPtr<IDispatchQueueScheduler> MakeJSCallInvokerScheduler(
+    Mso::DispatchQueueSettings const &settings,
     std::shared_ptr<facebook::react::CallInvoker> &&callInvoker,
     Mso::Functor<void(const Mso::ErrorCode &)> &&errorHandler,
     Mso::Promise<void> &&whenQuit = nullptr) noexcept;

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -5,12 +5,12 @@
 #include "MoveOnCopy.h"
 #include "MsoUtils.h"
 
+#include <AppModelHelpers.h>
 #include <Base/CoreNativeModules.h>
 #include <Threading/MessageDispatchQueue.h>
 #include <Threading/MessageQueueThreadFactory.h>
 #include <appModel.h>
 #include <comUtil/qiCast.h>
-
 #ifndef CORE_ABI
 #include <XamlUIService.h>
 #endif
@@ -132,7 +132,8 @@ struct BridgeUIBatchInstanceCallback final : public facebook::react::InstanceCal
   virtual ~BridgeUIBatchInstanceCallback() = default;
   void onBatchComplete() override {
     if (auto instance = m_wkInstance.GetStrongPtr()) {
-      if (instance->IsLoaded()) {
+      auto state = instance->State();
+      if (state != ReactInstanceState::HasError && state != ReactInstanceState::Unloaded) {
         if (instance->UseWebDebugger()) {
           // While using a CxxModule for UIManager (which we do when running under webdebugger)
           // We need to post the batch complete to the NativeQueue to ensure that the UIManager
@@ -469,8 +470,7 @@ void ReactInstanceWin::Initialize() noexcept {
             case JSIEngine::V8:
 #if defined(USE_V8)
             {
-              uint32_t length{0};
-              if (GetCurrentPackageFullName(&length, nullptr) != APPMODEL_ERROR_NO_PACKAGE) {
+              if (Microsoft::ReactNative::HasPackageIdentity()) {
                 preparedScriptStore =
                     std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(getApplicationTempFolder());
               } else {
@@ -679,7 +679,26 @@ ReactInstanceState ReactInstanceWin::State() const noexcept {
 void ReactInstanceWin::InitJSMessageThread() noexcept {
   m_instance.Exchange(std::make_shared<facebook::react::Instance>());
 
+  winrt::Microsoft::ReactNative::IReactNotificationService service = m_reactContext->Notifications();
+  Mso::DispatchQueueSettings queueSettings{};
+  queueSettings.TaskStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherTaskStartingEventName(), nullptr, nullptr);
+  };
+  queueSettings.IdleWaitStarting = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitStartingEventName(),
+        nullptr,
+        nullptr);
+  };
+  queueSettings.IdleWaitCompleted = [service](Mso::DispatchQueue const &) noexcept {
+    service.SendNotification(
+        winrt::Microsoft::ReactNative::ReactDispatcherHelper::JSDispatcherIdleWaitCompletedEventName(),
+        nullptr,
+        nullptr);
+  };
   auto scheduler = Mso::MakeJSCallInvokerScheduler(
+      queueSettings,
       m_instance.Load()->getJSCallInvoker(),
       Mso::MakeWeakMemberFunctor(this, &ReactInstanceWin::OnError),
       Mso::Copy(m_whenDestroyed));

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.h

@@ -153,7 +153,7 @@ class ReactInstanceWin final : public Mso::ActiveObject<IReactInstanceInternal>
   const bool m_useDirectDebugger : 1;
   const bool m_useWebDebugger : 1;
 
-  const Mso::CntPtr<ReactContext> m_reactContext;
+  const Mso::CntPtr<::Mso::React::ReactContext> m_reactContext;
 
   std::atomic<bool> m_isLoaded{false};
   std::atomic<bool> m_isDestroyed{false};

package/Microsoft.ReactNative/ReactPointerEventArgs.cpp

@@ -16,8 +16,18 @@ PointerEventKind ReactPointerEventArgs::Kind() const noexcept {
 }
 
 void ReactPointerEventArgs::Kind(PointerEventKind kind) noexcept {
-  // The only event type change that is supported is CaptureLost to End.
-  assert(kind == PointerEventKind::End && m_kind == PointerEventKind::CaptureLost);
+  // The only event type transitions that are supported are:
+  // 1. PointerEventKind::CaptureLost to PointerEventKind::End to support cases
+  //    where XAML firing the CaptureLost event should be treated as a gesture
+  //    completion event, e.g., for pointer events in selectable text that do
+  //    not result in text selection.
+  // 2. PointerEventKind::End to PointerEventKind::Cancel to support cases
+  //    where a custom view manager implementing `IViewManagerWithPointerEvents`
+  //    wants to cancel a gesture, e.g., for a custom drag handle where the end
+  //    of the gesture should not be treated as a completed press event.
+  assert(
+      (kind == PointerEventKind::End && m_kind == PointerEventKind::CaptureLost) ||
+      (kind == PointerEventKind::Cancel && m_kind == PointerEventKind::End));
   m_kind = kind;
 }
 

package/Microsoft.ReactNative/Utils/BatchingEventEmitter.cpp

@@ -3,6 +3,7 @@
 
 #include "pch.h"
 #include "BatchingEventEmitter.h"
+#include <UI.Xaml.Media.h>
 #include "DynamicWriter.h"
 #include "JSValueWriter.h"
 

package/Microsoft.ReactNative/Utils/Helpers.cpp

@@ -31,7 +31,7 @@ namespace Microsoft::ReactNative {
 // Instead of deduce view id directly from FrameworkElement.Tag, this do
 // additional check by uimanager.
 ReactId getViewId(const Mso::React::IReactContext &context, xaml::FrameworkElement const &fe) {
-  ReactId reactId;
+  ReactId reactId{};
   if (auto uiManager = Microsoft::ReactNative::GetNativeUIManager(context).lock()) {
     if (auto peer = uiManager->reactPeerOrContainerFrom(fe)) {
       reactId.isValid = true;

package/Microsoft.ReactNative/Utils/Helpers.h

@@ -18,7 +18,7 @@ struct ReactId {
 };
 
 template <typename T>
-inline typename T asEnum(winrt::Microsoft::ReactNative::JSValue const &obj) {
+inline T asEnum(winrt::Microsoft::ReactNative::JSValue const &obj) {
   return static_cast<T>(obj.AsInt64());
 }
 

package/Microsoft.ReactNative/Utils/PropertyUtils.h

@@ -149,10 +149,10 @@ bool TryUpdateForeground(
       }
     } else if (propertyValue.IsNull()) {
       element.ClearValue(T::ForegroundProperty());
-      UpdateControlForegroundResourceBrushes(element, nullptr);
       if (uielement) {
         uielement.HighContrastAdjustment(xaml::ElementHighContrastAdjustment::Application);
       }
+      UpdateControlForegroundResourceBrushes(element, nullptr);
     }
 
     return true;

package/Microsoft.ReactNative/Utils/TransformableText.h

@@ -24,7 +24,7 @@ struct TransformableText final {
         dwMapFlags |= LCMAP_TITLECASE;
         break;
       default:
-        nyi();
+        assert(false);
         return originalText;
     }