react-native-windows 0.73.11 → 0.74.0-preview.1

package/Microsoft.ReactNative/Modules/Timing.cpp

@@ -0,0 +1,325 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#undef Check
+
+#include "Timing.h"
+
+#include <InstanceManager.h>
+#include <UI.Xaml.Media.h>
+#include <Utils/ValueUtils.h>
+#include <XamlUtils.h>
+
+#include <unknwnbase.h>
+
+using namespace facebook::xplat;
+using namespace folly;
+namespace winrt {
+using namespace Windows::Foundation;
+using namespace xaml::Media;
+} // namespace winrt
+using namespace std;
+
+namespace Microsoft::ReactNative {
+
+//
+// IsAnimationFrameRequest
+//
+static bool IsAnimationFrameRequest(TTimeSpan period, bool repeat) {
+  return !repeat && period == std::chrono::milliseconds(1);
+}
+
+winrt::Windows::Foundation::TimeSpan TimeSpanFromMs(double ms) {
+  std::chrono::milliseconds dur((int64_t)ms);
+  return dur;
+}
+
+//
+// TimerQueue
+//
+
+TimerQueue::TimerQueue() {
+  std::make_heap(m_timerVector.begin(), m_timerVector.end());
+}
+
+void TimerQueue::Push(uint32_t id, TDateTime targetTime, TTimeSpan period, bool repeat) {
+  m_timerVector.emplace_back(id, targetTime, period, repeat);
+  std::push_heap(m_timerVector.begin(), m_timerVector.end());
+}
+
+void TimerQueue::Pop() {
+  std::pop_heap(m_timerVector.begin(), m_timerVector.end());
+  m_timerVector.pop_back();
+}
+
+Timer &TimerQueue::Front() {
+  return m_timerVector.front();
+}
+
+void TimerQueue::Remove(uint32_t id) {
+  // TODO: This is very inefficient, but doing this with a heap is inherently
+  // hard. If performance is not good
+  //	enough for the scenarios then a different structure is probably needed.
+  auto found = std::find(m_timerVector.begin(), m_timerVector.end(), id);
+  if (found != m_timerVector.end())
+    m_timerVector.erase(found);
+
+  std::make_heap(m_timerVector.begin(), m_timerVector.end());
+}
+
+bool TimerQueue::IsEmpty() {
+  return m_timerVector.empty();
+}
+
+std::unique_ptr<TimerRegistry> TimerRegistry::CreateTimerRegistry(
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &properties) noexcept {
+  auto registry = std::make_unique<TimerRegistry>();
+  registry->m_timingModule = std::make_shared<Timing>();
+  registry->m_timingModule->InitializeBridgeless(registry.get(), properties);
+  return registry;
+}
+
+TimerRegistry::~TimerRegistry() {
+  m_timingModule->DetachBridgeless();
+}
+
+double SchedulingTimeNow() {
+  const int64_t msFrom1601to1970 = 11644473600000;
+  return std::chrono::duration<double, std::milli>(TDateTime::clock::now().time_since_epoch()).count() -
+      msFrom1601to1970;
+}
+
+void TimerRegistry::createTimer(uint32_t timerID, double delayMS) {
+  m_timingModule->createTimer(timerID, delayMS, SchedulingTimeNow(), false);
+}
+void TimerRegistry::deleteTimer(uint32_t timerID) {
+  m_timingModule->deleteTimer(timerID);
+}
+void TimerRegistry::createRecurringTimer(uint32_t timerID, double delayMS) {
+  m_timingModule->createTimer(timerID, delayMS, SchedulingTimeNow(), true);
+}
+
+void TimerRegistry::callTimers(const vector<uint32_t> &ids) noexcept {
+#ifdef USE_FABRIC
+  if (auto timerManager = m_timerManager.lock()) {
+    for (auto id : ids) {
+      timerManager->callTimer(id);
+    }
+  }
+#endif
+}
+
+// When running bridgeless mode timers are managed by TimerManager
+void TimerRegistry::setTimerManager(std::weak_ptr<facebook::react::TimerManager> timerManager) {
+#ifdef USE_FABRIC
+  m_timerManager = timerManager;
+#endif
+}
+
+//
+// Timing
+//
+
+void Timing::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+  m_properties = reactContext.Properties().Handle();
+  m_usePostForRendering = !xaml::TryGetCurrentApplication();
+  m_uiDispatcher = m_context.UIDispatcher().Handle();
+}
+
+void Timing::InitializeBridgeless(
+    TimerRegistry *timerRegistry,
+    const winrt::Microsoft::ReactNative::IReactPropertyBag &properties) noexcept {
+  m_timerRegistry = timerRegistry;
+  m_properties = properties;
+  m_usePostForRendering = !xaml::TryGetCurrentApplication();
+  m_uiDispatcher = {properties.Get(winrt::Microsoft::ReactNative::ReactDispatcherHelper::UIDispatcherProperty())
+                        .try_as<winrt::Microsoft::ReactNative::IReactDispatcher>()};
+}
+
+void Timing::DetachBridgeless() {
+  m_timerRegistry = nullptr;
+}
+
+void Timing::OnTick() {
+  vector<uint32_t> readyTimers;
+  auto now = TDateTime::clock::now();
+
+  auto emittedAnimationFrame = false;
+  while (!m_timerQueue.IsEmpty() && m_timerQueue.Front().TargetTime < now) {
+    // Pop first timer from the queue and add it to list of timers ready to fire
+    Timer next = m_timerQueue.Front();
+    m_timerQueue.Pop();
+    readyTimers.push_back(next.Id);
+
+    // If timer is repeating push it back onto the queue for the next repetition
+    if (next.Repeat)
+      m_timerQueue.Push(next.Id, now + next.Period, next.Period, true);
+    else if (IsAnimationFrameRequest(next.Period, next.Repeat))
+      emittedAnimationFrame = true;
+  }
+
+  if (m_timerQueue.IsEmpty()) {
+    StopTicks();
+  } else if (m_usePostForRendering && m_usingRendering && emittedAnimationFrame) {
+    PostRenderFrame(); // Repost
+  } else if (!m_usingRendering || !emittedAnimationFrame) {
+    // If we're using a rendering callback, check if any animation frame
+    // requests were emitted in this tick. If not, start the dispatcher timer.
+    // This extra frame gives JS a chance to enqueue an additional animation
+    // frame request before switching tick schedulers.
+    StartDispatcherTimer();
+  }
+
+  if (!readyTimers.empty()) {
+    if (m_context) {
+      winrt::Microsoft::ReactNative::JSValueArray readyTimersJsArray;
+      for (auto id : readyTimers) {
+        readyTimersJsArray.push_back({id});
+      }
+      m_context.CallJSFunction(
+          L"JSTimers", L"callTimers", winrt::Microsoft::ReactNative::JSValueArray{std::move(readyTimersJsArray)});
+    } else if (m_timerRegistry) {
+      m_timerRegistry->callTimers(readyTimers);
+    }
+  }
+}
+
+winrt::Microsoft::ReactNative::ITimer Timing::EnsureDispatcherTimer() {
+  if (!m_dispatcherQueueTimer) {
+    m_dispatcherQueueTimer = winrt::Microsoft::ReactNative::Timer::Create(m_properties);
+    m_dispatcherQueueTimer.Tick([wkThis = std::weak_ptr(this->shared_from_this())](auto &&...) {
+      if (auto pThis = wkThis.lock()) {
+        pThis->OnTick();
+      }
+    });
+  }
+
+  return m_dispatcherQueueTimer;
+}
+
+void Timing::PostRenderFrame() noexcept {
+  assert(m_usePostForRendering);
+  m_usingRendering = true;
+  if (auto uiDispatcher = m_uiDispatcher.get()) {
+    uiDispatcher.Post([wkThis = std::weak_ptr(this->shared_from_this())]() {
+      if (auto pThis = wkThis.lock()) {
+        pThis->m_usingRendering = false;
+        pThis->OnTick();
+      }
+    });
+  }
+}
+
+void Timing::StartRendering() {
+  if (m_dispatcherQueueTimer)
+    m_dispatcherQueueTimer.Stop();
+
+  if (m_usePostForRendering) {
+    PostRenderFrame();
+    return;
+  }
+  m_rendering.revoke();
+  m_usingRendering = true;
+  m_rendering = xaml::Media::CompositionTarget::Rendering(
+      winrt::auto_revoke,
+      [wkThis = std::weak_ptr(this->shared_from_this())](
+          const winrt::IInspectable &, const winrt::IInspectable & /*args*/) {
+        if (auto pThis = wkThis.lock()) {
+          pThis->OnTick();
+        }
+      });
+}
+
+void Timing::StartDispatcherTimer() {
+  const auto &nextTimer = m_timerQueue.Front();
+  m_rendering.revoke();
+  m_usingRendering = false;
+  auto timer = EnsureDispatcherTimer();
+  timer.Interval(std::max(nextTimer.TargetTime - TDateTime::clock::now(), TTimeSpan::zero()));
+  timer.Start();
+}
+
+void Timing::StopTicks() {
+  m_rendering.revoke();
+  m_usingRendering = false;
+  if (m_dispatcherQueueTimer)
+    m_dispatcherQueueTimer.Stop();
+}
+
+void Timing::createTimerOnQueue(uint32_t id, double duration, double jsSchedulingTime, bool repeat) noexcept {
+  if (duration == 0 && !repeat) {
+    if (m_context) {
+      m_context.CallJSFunction(
+          L"JSTimers",
+          L"callTimers",
+          winrt::Microsoft::ReactNative::JSValueArray{winrt::Microsoft::ReactNative::JSValueArray{id}});
+    } else if (m_timerRegistry) {
+      m_timerRegistry->callTimers({id});
+    }
+
+    return;
+  }
+
+  // Convert double duration in ms to TimeSpan
+  auto period = TimeSpanFromMs(duration);
+  const int64_t msFrom1601to1970 = 11644473600000;
+  TDateTime scheduledTime(TimeSpanFromMs(jsSchedulingTime + msFrom1601to1970));
+  auto initialTargetTime = scheduledTime + period;
+  m_timerQueue.Push(id, initialTargetTime, period, repeat);
+  if (!m_usingRendering) {
+    if (IsAnimationFrameRequest(period, repeat)) {
+      StartRendering();
+    } else if (initialTargetTime <= m_timerQueue.Front().TargetTime) {
+      StartDispatcherTimer();
+    }
+  }
+}
+
+void Timing::createTimer(uint32_t id, double duration, double jsSchedulingTime, bool repeat) noexcept {
+  if (m_context) {
+    winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueue(
+        m_context.Handle(),
+        [wkThis = std::weak_ptr(this->shared_from_this()), id, duration, jsSchedulingTime, repeat]() {
+          if (auto pThis = wkThis.lock()) {
+            pThis->createTimerOnQueue(static_cast<uint32_t>(id), duration, jsSchedulingTime, repeat);
+          }
+        });
+  } else if (auto uiDispatcher = m_uiDispatcher.get()) {
+    uiDispatcher.Post([wkThis = std::weak_ptr(this->shared_from_this()), id, duration, jsSchedulingTime, repeat]() {
+      if (auto pThis = wkThis.lock()) {
+        pThis->createTimerOnQueue(static_cast<uint32_t>(id), duration, jsSchedulingTime, repeat);
+      }
+    });
+  }
+}
+
+void Timing::deleteTimerOnQueue(uint32_t id) noexcept {
+  m_timerQueue.Remove(id);
+  if (m_timerQueue.IsEmpty())
+    StopTicks();
+}
+
+void Timing::deleteTimer(uint32_t id) noexcept {
+  if (m_context) {
+    winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::PostToUIBatchingQueue(
+        m_context.Handle(), [wkThis = std::weak_ptr(this->shared_from_this()), id]() {
+          if (auto pThis = wkThis.lock()) {
+            pThis->deleteTimerOnQueue(static_cast<int64_t>(id));
+          }
+        });
+  } else if (auto uiDispatcher = m_uiDispatcher.get()) {
+    uiDispatcher.Post([wkThis = std::weak_ptr(this->shared_from_this()), id]() {
+      if (auto pThis = wkThis.lock()) {
+        pThis->deleteTimerOnQueue(static_cast<int64_t>(id));
+      }
+    });
+  }
+}
+
+void Timing::setSendIdleEvents(bool /*sendIdleEvents*/) noexcept {
+  // TODO: Implement.
+}
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Modules/Timing.h

@@ -0,0 +1,121 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "../../codegen/NativeTimingSpec.g.h"
+
+#include <CppWinRTIncludes.h>
+#include <ReactCoreInjection.h>
+#include <react/runtime/PlatformTimerRegistry.h>
+#include <react/runtime/TimerManager.h>
+
+namespace Microsoft::ReactNative {
+
+typedef winrt::Windows::Foundation::DateTime TDateTime;
+typedef winrt::Windows::Foundation::TimeSpan TTimeSpan;
+
+class TimingModule;
+struct Timing;
+
+struct Timer {
+  Timer(uint32_t id, TDateTime targetTime, TTimeSpan period, bool repeat) {
+    Id = id;
+    TargetTime = targetTime;
+    Period = period;
+    Repeat = repeat;
+  }
+
+  bool operator<(const Timer &timer) const {
+    return timer.TargetTime < TargetTime;
+  }
+
+  bool operator==(uint32_t id) const {
+    return id == Id;
+  }
+
+  uint32_t Id;
+  TDateTime TargetTime;
+  TTimeSpan Period;
+  bool Repeat;
+};
+
+class TimerQueue {
+ public:
+  TimerQueue();
+
+  void Push(uint32_t id, TDateTime targetTime, TTimeSpan period, bool repeat);
+  void Pop();
+  Timer &Front();
+  void Remove(uint32_t id);
+
+  bool IsEmpty();
+
+ private:
+  std::vector<Timer> m_timerVector;
+};
+
+struct TimerRegistry : public facebook::react::PlatformTimerRegistry {
+  static std::unique_ptr<TimerRegistry> CreateTimerRegistry(
+      const winrt::Microsoft::ReactNative::IReactPropertyBag &properties) noexcept;
+
+  ~TimerRegistry();
+
+  void createTimer(uint32_t timerID, double delayMS) override;
+  void deleteTimer(uint32_t timerID) override;
+  void createRecurringTimer(uint32_t timerID, double delayMS) override;
+
+  // When running bridgeless mode timers are managed by TimerManager
+  void setTimerManager(std::weak_ptr<facebook::react::TimerManager> timerManager);
+
+  void callTimers(const std::vector<uint32_t> &ids) noexcept;
+
+ private:
+  std::weak_ptr<facebook::react::TimerManager> m_timerManager;
+  std::shared_ptr<Timing> m_timingModule;
+};
+
+REACT_MODULE(Timing)
+struct Timing : public std::enable_shared_from_this<Timing> {
+  // Spec enforces using double for ids instead of uint32_t
+  // using ModuleSpec = ReactNativeSpecs::TimingSpec;
+
+ public:
+  REACT_INIT(Initialize)
+  void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  void InitializeBridgeless(
+      TimerRegistry *timerRegistry,
+      const winrt::Microsoft::ReactNative::IReactPropertyBag &properties) noexcept;
+  void DetachBridgeless();
+
+  REACT_METHOD(createTimer)
+  void createTimer(uint32_t id, double duration, double jsSchedulingTime, bool repeat) noexcept;
+
+  REACT_METHOD(deleteTimer)
+  void deleteTimer(uint32_t id) noexcept;
+  REACT_METHOD(setSendIdleEvents)
+  void setSendIdleEvents(bool sendIdleEvents) noexcept;
+
+ private:
+  void createTimerOnQueue(uint32_t id, double duration, double jsSchedulingTime, bool repeat) noexcept;
+  void deleteTimerOnQueue(uint32_t id) noexcept;
+  void OnTick();
+  winrt::Microsoft::ReactNative::ITimer EnsureDispatcherTimer();
+  void StartRendering();
+  void PostRenderFrame() noexcept;
+  void StartDispatcherTimer();
+  void StopTicks();
+
+  winrt::Microsoft::ReactNative::ReactContext m_context; // !bridgeless
+  TimerRegistry *m_timerRegistry{nullptr}; // bridgeless
+  winrt::Microsoft::ReactNative::IReactPropertyBag m_properties{nullptr};
+  TimerQueue m_timerQueue;
+  xaml::Media::CompositionTarget::Rendering_revoker m_rendering;
+  winrt::Microsoft::ReactNative::ITimer m_dispatcherQueueTimer{nullptr};
+  winrt::weak_ref<winrt::Microsoft::ReactNative::IReactDispatcher> m_uiDispatcher;
+  bool m_usingRendering{false};
+  bool m_usePostForRendering{false};
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/QuirkSettings.cpp

@@ -71,6 +71,28 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> SuppressWindowFocusOnViewFo
   return propId;
 }
 
+winrt::Microsoft::ReactNative::ReactPropertyId<bool> UseRuntimeSchedulerProperty() noexcept {
+  winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{L"ReactNative.QuirkSettings", L"UseRuntimeScheduler"};
+
+  return propId;
+}
+
+winrt::Microsoft::ReactNative::ReactPropertyId<bool> IsBridgelessProperty() noexcept {
+  winrt::Microsoft::ReactNative::ReactPropertyId<bool> propId{L"ReactNative", L"IsBridgeless"};
+
+  return propId;
+}
+
+/*static*/ bool QuirkSettings::GetIsBridgeless(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept {
+  return properties.Get(IsBridgelessProperty()).value_or(false);
+}
+
+/*static*/ void QuirkSettings::SetIsBridgeless(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+    bool value) noexcept {
+  properties.Set(IsBridgelessProperty(), value);
+}
+
 #pragma region IDL interface
 
 /*static*/ void QuirkSettings::SetMatchAndroidAndIOSStretchBehavior(
@@ -109,6 +131,12 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> SuppressWindowFocusOnViewFo
   ReactPropertyBag(settings.Properties()).Set(SuppressWindowFocusOnViewFocusProperty(), value);
 }
 
+/*static*/ void QuirkSettings::SetUseRuntimeScheduler(
+    winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+    bool value) noexcept {
+  ReactPropertyBag(settings.Properties()).Set(UseRuntimeSchedulerProperty(), value);
+}
+
 #pragma endregion IDL interface
 
 /*static*/ bool QuirkSettings::GetMatchAndroidAndIOSStretchBehavior(ReactPropertyBag properties) noexcept {
@@ -137,4 +165,8 @@ winrt::Microsoft::ReactNative::ReactPropertyId<bool> SuppressWindowFocusOnViewFo
   return properties.Get(SuppressWindowFocusOnViewFocusProperty()).value_or(false);
 }
 
+/*static*/ bool QuirkSettings::GetUseRuntimeScheduler(ReactPropertyBag properties) noexcept {
+  return properties.Get(UseRuntimeSchedulerProperty()).value_or(true);
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/QuirkSettings.h

@@ -29,6 +29,7 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static winrt::Microsoft::ReactNative::BackNavigationHandlerKind GetBackHandlerKind(
       winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
   static bool GetSuppressWindowFocusOnViewFocus(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+  static bool GetUseRuntimeScheduler(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
   static bool GetEnableFabric(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
@@ -38,6 +39,9 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static bool GetMapWindowDeactivatedToAppStateInactive(
       winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
 
+  static bool GetIsBridgeless(winrt::Microsoft::ReactNative::ReactPropertyBag properties) noexcept;
+  static void SetIsBridgeless(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties, bool value) noexcept;
+
 #pragma region Public API - part of IDL interface
   static void SetMatchAndroidAndIOSStretchBehavior(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
@@ -59,6 +63,11 @@ struct QuirkSettings : QuirkSettingsT<QuirkSettings> {
   static void SetSuppressWindowFocusOnViewFocus(
       winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
       bool value) noexcept;
+
+  static void SetUseRuntimeScheduler(
+      winrt::Microsoft::ReactNative::ReactInstanceSettings settings,
+      bool value) noexcept;
+
 #pragma endregion Public API - part of IDL interface
 };
 

package/Microsoft.ReactNative/QuirkSettings.idl

@@ -59,5 +59,11 @@ namespace Microsoft.ReactNative
         "window of that view to get focus as well. Set this setting to true to prevent focus of a blurred "
         "window when a view in that window is programmatically focused.")
     static void SetSuppressWindowFocusOnViewFocus(ReactInstanceSettings settings, Boolean value);
+
+    DOC_STRING(
+        "By default `react-native-windows` will use the new RuntimeScheduler."
+        "Setting this to false will revert the behavior to previous scheduling logic.")
+    static void SetUseRuntimeScheduler(ReactInstanceSettings settings, Boolean value);
   }
+
 } // namespace Microsoft.ReactNative

package/Microsoft.ReactNative/ReactCoreInjection.cpp

@@ -109,6 +109,21 @@ void ReactCoreInjection::SetTopLevelWindowId(const IReactPropertyBag &properties
   ReactPropertyBag(properties).Set(TopLevelWindowIdPropertyId(), windowId);
 }
 
+static const ReactPropertyId<TimerFactory> &TimerFactoryPropertyId() noexcept {
+  static const ReactPropertyId<TimerFactory> prop{L"ReactNative.Injection", L"TimerFactory"};
+  return prop;
+}
+
+void ReactCoreInjection::SetTimerFactory(
+    const IReactPropertyBag &properties,
+    const TimerFactory &timerFactory) noexcept {
+  ReactPropertyBag(properties).Set(TimerFactoryPropertyId(), timerFactory);
+}
+
+TimerFactory ReactCoreInjection::GetTimerFactory(const IReactPropertyBag &properties) noexcept {
+  return ReactPropertyBag(properties).Get(TimerFactoryPropertyId()).value_or(nullptr);
+}
+
 ReactViewHost::ReactViewHost(
     const ReactNative::ReactNativeHost &host,
     Mso::React::IReactViewHost &viewHost,

package/Microsoft.ReactNative/ReactCoreInjection.h

@@ -52,6 +52,10 @@ struct ReactCoreInjection : ReactCoreInjectionT<ReactCoreInjection> {
 
   static uint64_t GetTopLevelWindowId(const IReactPropertyBag &properties) noexcept;
   static void SetTopLevelWindowId(const IReactPropertyBag &properties, uint64_t windowId) noexcept;
+
+  static ITimer CreateTimer(const IReactPropertyBag &properties);
+  static TimerFactory GetTimerFactory(const IReactPropertyBag &properties) noexcept;
+  static void SetTimerFactory(const IReactPropertyBag &properties, const TimerFactory &timerFactory) noexcept;
 };
 
 struct ReactViewHost : public winrt::implements<ReactViewHost, IReactViewHost> {

package/Microsoft.ReactNative/ReactCoreInjection.idl

@@ -4,6 +4,7 @@
 import "IReactContext.idl";
 import "ReactNativeHost.idl";
 import "IJSValueReader.idl";
+import "Timer.idl";
 
 #include "DocString.h"
 
@@ -27,6 +28,10 @@ DOC_STRING("Settings per each IReactViewHost associated with an IReactHost insta
     };
   };
 
+  [experimental]
+  [webhosthidden]
+  delegate ITimer TimerFactory();
+
   [experimental]
   [webhosthidden]
   DOC_STRING(
@@ -102,6 +107,9 @@ DOC_STRING("Settings per each IReactViewHost associated with an IReactHost insta
       "This must be manually provided to the @ReactInstanceSettings object when using ReactNativeWindows"
       "without XAML for certain APIs work correctly.")
     static void SetTopLevelWindowId(IReactPropertyBag properties, UInt64 windowId);
+
+    DOC_STRING("Sets a factory method for creating custom timers, in environments where system dispatch timers should not be used.")
+    static void SetTimerFactory(IReactPropertyBag properties, TimerFactory timerFactory);
   }
 
 

package/Microsoft.ReactNative/ReactHost/IReactInstance.h

@@ -5,7 +5,7 @@
 #include <InstanceManager.h>
 
 #include <DevSettings.h>
-#include <Folly/dynamic.h>
+#include <folly/dynamic.h>
 #include "XamlView.h"
 
 #include <functional>

package/Microsoft.ReactNative/ReactHost/MsoReactContext.cpp

@@ -3,7 +3,7 @@
 
 #include "MsoReactContext.h"
 #include <winrt/Microsoft.ReactNative.h>
-#include "Microsoft.ReactNative/IReactNotificationService.h"
+#include "IReactNotificationService.h"
 #include "MsoUtils.h"
 #include "ReactInstanceWin.h"