basalt-win32 0.2.5 → 0.2.7

package/native/win32/Win32AnimationChoreographer.cpp

@@ -19,33 +19,34 @@ Win32AnimationChoreographer::~Win32AnimationChoreographer() {
   detach();
 }
 
-void Win32AnimationChoreographer::resume() {
-  if (running_.exchange(true)) {
-    return;
-  }
-  // Not `SetTimer`. A sixty-hertz WM_TIMER is exactly the arrangement that
-  // stops working in an app that repaints continuously, which is to say in
-  // every app with an animation worth running. See win32/Win32UiTimer.h.
-  timer_ = scheduleUiTimer(kFrameIntervalMs, true, [this] { onFrame(); });
-}
-
-void Win32AnimationChoreographer::pause() {
-  if (!running_.exchange(false)) {
-    return;
+void Win32AnimationChoreographer::runningChanged() {
+  const std::lock_guard<std::mutex> lock(timerMutex_);
+  const bool want = running();
+  if (want && timer_ == 0) {
+    // Not `SetTimer`. A sixty-hertz WM_TIMER is exactly the arrangement that
+    // stops working in an app that repaints continuously, which is to say in
+    // every app with an animation worth running. See win32/Win32UiTimer.h.
+    timer_ = scheduleUiTimer(kFrameIntervalMs, true, [this] { onFrame(); });
+  } else if (!want && timer_ != 0) {
+    // Before this returns, nothing of ours is still in flight: `cancelUiTimer`
+    // waits out a delivery already on a pool thread, which is what makes the
+    // `this` captured above safe to destroy afterwards. It does not take
+    // timerMutex_, so waiting here holding it cannot deadlock.
+    cancelUiTimer(timer_);
+    timer_ = 0;
   }
-  // Before this returns, nothing of ours is still in flight: `cancelUiTimer`
-  // waits out a delivery already on a pool thread, which is what makes the
-  // `this` captured above safe to destroy afterwards.
-  cancelUiTimer(timer_);
-  timer_ = 0;
 }
 
 void Win32AnimationChoreographer::detach() {
-  pause();
+  const std::lock_guard<std::mutex> lock(timerMutex_);
+  if (timer_ != 0) {
+    cancelUiTimer(timer_);
+    timer_ = 0;
+  }
 }
 
 void Win32AnimationChoreographer::onFrame() {
-  if (!running_.load()) {
+  if (!running()) {
     return;
   }
   // A steady clock rather than the wall clock: an animation must not jump when
@@ -53,7 +54,7 @@ void Win32AnimationChoreographer::onFrame() {
   const auto now = std::chrono::steady_clock::now().time_since_epoch();
   const auto milliseconds =
       std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(now);
-  onAnimationFrame(static_cast<facebook::react::AnimationTimestamp>(milliseconds.count()));
+  deliverFrame(static_cast<facebook::react::AnimationTimestamp>(milliseconds.count()));
 }
 
 } // namespace basalt

package/native/win32/Win32AnimationChoreographer.h

@@ -28,21 +28,20 @@
 
 #pragma once
 
-#include <react/renderer/animationbackend/AnimationChoreographer.h>
+#include "DisplayChoreographer.h"
 
-#include <atomic>
 #include <cstdint>
+#include <mutex>
 
 namespace basalt {
 
-class Win32AnimationChoreographer final : public facebook::react::AnimationChoreographer {
+// Also what paces requestAnimationFrame here; core/DisplayChoreographer.h
+// decides when the timer runs.
+class Win32AnimationChoreographer final : public DisplayChoreographer {
  public:
   Win32AnimationChoreographer() = default;
   ~Win32AnimationChoreographer() override;
 
-  void resume() override;
-  void pause() override;
-
   // Stops the timer for good. Called on the way out, before the manager this
   // feeds is released.
   void detach();
@@ -50,8 +49,14 @@ class Win32AnimationChoreographer final : public facebook::react::AnimationChore
   // Called from the timer, on the UI thread.
   void onFrame();
 
+ protected:
+  // Starts or stops the timer to match running(). Any thread.
+  void runningChanged() override;
+
  private:
-  std::atomic<bool> running_{false};
+  // runningChanged() can arrive from the JS thread and detach() from the UI
+  // thread; the timer id is the one thing they share.
+  std::mutex timerMutex_;
   // A `basalt::UiTimerId` rather than a `SetTimer` handle, and not for
   // tidiness: WM_TIMER ranks below WM_PAINT, so on this timer an app that
   // repaints continuously -- anything with a `<Canvas>` -- stopped getting

package/native/win32/main_win32.cpp

@@ -38,6 +38,7 @@
 
 #include "Win32AnimationChoreographer.h"
 #include "CrashHandler.h"
+#include "AnimationFrames.h"
 #include "AppIdentity.h"
 #include "AppPaths.h"
 #include "DevMenu.h"
@@ -701,6 +702,15 @@ void installBindings(facebook::jsi::Runtime &runtime) {
   // runtime. See core/TurboModuleProxy.h.
   basalt::installTurboModuleProxy(runtime);
   basalt::installExpoRuntime(runtime);
+  // requestAnimationFrame at the display's rate, over React Native's setTimeout(0).
+  // After TimerManager's globals, which ReactInstance installs just before this.
+  // See core/AnimationFrames.h.
+  basalt::AnimationFrames::install(
+      runtime, gHost.choreographer, [](std::function<void(facebook::jsi::Runtime &)> task) {
+        if (gHost.reactHost != nullptr) {
+          gHost.reactHost->runOnRuntimeScheduler(std::move(task));
+        }
+      });
 }
 
 std::shared_ptr<const ContextContainer> makeContextContainer() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basalt-win32",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "The Windows view layer for basalt-core: a Win32 and Direct2D view layer, a Fabric mounting manager, and a host. Everything behind them is in basalt-core.",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,6 @@
     "react-native": "*"
   },
   "dependencies": {
-    "basalt-core": "0.2.5"
+    "basalt-core": "0.2.7"
   }
 }