basalt-win32 0.2.1 → 0.2.3

package/native/win32/Win32UiTimer.cpp

@@ -0,0 +1,139 @@
+#include "Win32UiTimer.h"
+
+#include <windows.h>
+
+#include "PlatformServices.h"
+#include "Win32UiThread.h"
+
+#include <mutex>
+#include <unordered_map>
+#include <utility>
+
+namespace basalt {
+namespace {
+
+struct Entry {
+  std::function<void()> callback;
+  PTP_TIMER handle = nullptr;
+  bool repeating = false;
+};
+
+struct Registry {
+  std::mutex mutex;
+  std::unordered_map<UiTimerId, Entry> timers;
+  UiTimerId next = 1;
+};
+
+Registry &registry() {
+  static Registry instance;
+  return instance;
+}
+
+// Closing a thread-pool timer is three calls and the order is not optional:
+// stop it, wait out a callback that may already be running on a pool thread,
+// and only then release the handle. Skipping the wait is the classic way to
+// free a timer out from under its own callback.
+//
+// Called with the registry lock *not* held: the wait blocks until a pool
+// thread leaves `onExpiry`, and `onExpiry` takes that lock.
+void closeTimer(PTP_TIMER handle) {
+  if (handle == nullptr) {
+    return;
+  }
+  SetThreadpoolTimer(handle, nullptr, 0, 0);
+  WaitForThreadpoolTimerCallbacks(handle, TRUE);
+  CloseThreadpoolTimer(handle);
+}
+
+// On the UI thread, one delay later. Everything about the timer is re-read
+// here rather than captured, because the gap between the pool thread posting
+// this and the loop running it is exactly when a cancel arrives.
+void deliver(UiTimerId id) {
+  std::function<void()> callback;
+  PTP_TIMER finished = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    const auto found = registry().timers.find(id);
+    if (found == registry().timers.end()) {
+      return;
+    }
+    callback = found->second.callback;
+    if (!found->second.repeating) {
+      // Out of the table before the callback runs, so that a one-shot which
+      // schedules its successor cannot collide with itself, and so that a
+      // `cancelUiTimer` on this id from inside the callback is the no-op the
+      // header promises.
+      finished = found->second.handle;
+      registry().timers.erase(found);
+    }
+  }
+  closeTimer(finished);
+  callback();
+}
+
+VOID CALLBACK onExpiry(PTP_CALLBACK_INSTANCE /*instance*/, PVOID context, PTP_TIMER /*timer*/) {
+  const auto id = static_cast<UiTimerId>(reinterpret_cast<std::uintptr_t>(context));
+  // Nothing is read here: the pool thread's only job is to say when. Which is
+  // also why the id travels rather than a pointer -- the entry may be gone by
+  // the time this lands.
+  postToUiThread([id] { deliver(id); });
+}
+
+} // namespace
+
+UiTimerId scheduleUiTimer(unsigned delayMs, bool repeating, std::function<void()> callback) {
+  // See the header: with no loop to post to, a timer has nowhere to arrive,
+  // and pretending otherwise would run the callback on a pool thread.
+  if (!hasUiThread() || callback == nullptr) {
+    return 0;
+  }
+
+  UiTimerId id = 0;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    id = registry().next++;
+  }
+
+  PTP_TIMER handle = CreateThreadpoolTimer(
+      onExpiry, reinterpret_cast<PVOID>(static_cast<std::uintptr_t>(id)), nullptr);
+  if (handle == nullptr) {
+    return 0;
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    registry().timers[id] = Entry{std::move(callback), handle, repeating};
+  }
+
+  // Negative is relative, in hundred-nanosecond units, which is the one piece
+  // of this API that reads like a mistake and is not.
+  LARGE_INTEGER relative{};
+  relative.QuadPart = -static_cast<LONGLONG>(delayMs) * 10000;
+  FILETIME due{};
+  due.dwLowDateTime = relative.LowPart;
+  due.dwHighDateTime = static_cast<DWORD>(relative.HighPart);
+  SetThreadpoolTimer(handle, &due, repeating ? static_cast<DWORD>(delayMs) : 0, 0);
+  return id;
+}
+
+void cancelUiTimer(UiTimerId id) {
+  if (id == 0) {
+    return;
+  }
+  PTP_TIMER handle = nullptr;
+  {
+    std::lock_guard<std::mutex> lock(registry().mutex);
+    const auto found = registry().timers.find(id);
+    if (found == registry().timers.end()) {
+      return;
+    }
+    handle = found->second.handle;
+    registry().timers.erase(found);
+  }
+  // Outside the lock, because the wait inside waits for `onExpiry` to finish
+  // and `onExpiry` wants the lock. A delivery already posted to the loop is
+  // harmless: `deliver` looks the id up and finds nothing.
+  closeTimer(handle);
+}
+
+} // namespace basalt

package/native/win32/Win32UiTimer.h

@@ -0,0 +1,65 @@
+// A delay that arrives, in an app that is busy drawing.
+//
+// `SetTimer` is the obvious way to wait on Windows and it is not a reliable
+// one. `WM_TIMER` is not posted: it is *synthesised* by `GetMessage` and
+// `PeekMessage`, and only when the queue holds nothing else at all. It ranks
+// below posted messages, below input, and -- the part that matters here --
+// below `WM_PAINT`. An app that repaints whenever something changes is fine.
+// An app that repaints continuously never gives the queue the empty moment a
+// `WM_TIMER` needs, and its timers simply stop.
+//
+// That is not hypothetical and it is not rare. Measured on kino, an editor
+// whose preview is a Skia `<Canvas>`: 120 `WM_PAINT` and 250 marshalled work
+// items a second while *idle*, and six `WM_TIMER` in twenty-five seconds. A
+// 250ms poll fired four times and then never again; a one-shot quit never
+// fired at all, so every automated run of that app had to be killed. The
+// other two desktops have no such ordering -- a CFRunLoop timer and a GLib
+// source are both ordinary sources with no paint above them -- so this is a
+// place where the Windows host was quietly worse than its peers rather than
+// differently spelled.
+//
+// So the waiting happens off the UI thread, on a thread-pool timer, and the
+// delivery is `postToUiThread` -- a posted message, which outranks both paint
+// and timer, and which is the path every mount already takes. The callback
+// still runs on the UI thread, which is the only property any caller wanted
+// from `SetTimer` in the first place.
+//
+// ## Without a UI thread
+//
+// Nothing is delivered. A host installs the message-only window before React
+// Native starts; the unit tests do not, because they have no loop. Under
+// `SetTimer` that already meant "never fires" -- a `WM_TIMER` with nobody to
+// dispatch it -- and keeping it that way is what lets the suite go on testing
+// the code around these timers without growing a scheduler. A test that wants
+// one installs a loop and pumps it, as the Skia canvas test does.
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+
+namespace basalt {
+
+// What `scheduleUiTimer` hands back. Zero is "nothing was scheduled", which
+// `cancelUiTimer` accepts, so a caller can keep one of these in a field and
+// cancel it without asking whether it ever started.
+using UiTimerId = std::uint64_t;
+
+// Runs `callback` on the UI thread after `delayMs`, and every `delayMs`
+// after that when `repeating`.
+//
+// The period is a floor rather than a promise, exactly as `SetTimer`'s was:
+// the work is posted, so it arrives after whatever the loop is already
+// holding. What is different is that it arrives.
+UiTimerId scheduleUiTimer(unsigned delayMs, bool repeating, std::function<void()> callback);
+
+// Stops it. Safe on an id that already fired, on one that was never
+// scheduled, and on the running timer's own id from inside its callback --
+// which is how a one-shot that reschedules itself is written.
+//
+// Returns having waited for any delivery already in flight on a pool thread,
+// so a caller may destroy what the callback captured. It must be called from
+// the UI thread, which every caller here is on.
+void cancelUiTimer(UiTimerId id);
+
+} // namespace basalt

package/native/win32/Win32WindowControl.cpp

@@ -21,17 +21,40 @@
 // scale factor. GetDpiForWindow would answer for the window's monitor only.
 #include <shellscalingapi.h>
 
+#include "Win32AppWindow.h"
+
 namespace basalt {
 
 namespace {
 
+// The window a call means, which is the lookup's answer where there is one.
+HWND window(facebook::react::SurfaceId id) { return win32AppWindowFor(id); }
+
+Win32AppWindowLookup &lookup() {
+  static Win32AppWindowLookup value;
+  return value;
+}
+
+} // namespace
 
-HWND window() {
+HWND win32AppWindow() {
   HWND active = GetActiveWindow();
   return active != nullptr ? active : GetForegroundWindow();
 }
 
-} // namespace
+void setWin32AppWindowLookup(Win32AppWindowLookup value) { lookup() = std::move(value); }
+
+HWND win32AppWindowFor(facebook::react::SurfaceId id) {
+  if (id != kAppWindow && lookup()) {
+    if (HWND found = lookup()(id)) {
+      return found;
+    }
+    // An id nobody knows is the app's own window rather than nothing: a window
+    // that closed between a render and the call after it is the ordinary way
+    // to get here. See AppKitAppWindow.h, which says the same.
+  }
+  return win32AppWindow();
+}
 
 // Every monitor, through the callback API that is the only way to ask.
 //
@@ -99,9 +122,9 @@ PointerPosition pointerPosition() {
   return where;
 }
 
-WindowBounds windowBounds() {
+WindowBounds windowBounds(facebook::react::SurfaceId id) {
   WindowBounds bounds;
-  HWND target = window();
+  HWND target = window(id);
   if (target == nullptr) {
     return bounds;
   }
@@ -138,8 +161,8 @@ WindowBounds windowBounds() {
   return bounds;
 }
 
-void setWindowSize(double width, double height) {
-  HWND target = window();
+void setWindowSize(facebook::react::SurfaceId id, double width, double height) {
+  HWND target = window(id);
   if (target == nullptr || width <= 0.0 || height <= 0.0) {
     return;
   }
@@ -160,8 +183,8 @@ void setWindowSize(double width, double height) {
                SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void setWindowPosition(double x, double y) {
-  HWND target = window();
+void setWindowPosition(facebook::react::SurfaceId id, double x, double y) {
+  HWND target = window(id);
   if (target == nullptr) {
     return;
   }
@@ -174,8 +197,8 @@ void setWindowPosition(double x, double y) {
                SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void centerWindow() {
-  HWND target = window();
+void centerWindow(facebook::react::SurfaceId id) {
+  HWND target = window(id);
   if (target == nullptr) {
     return;
   }
@@ -200,8 +223,8 @@ void centerWindow() {
   SetWindowPos(target, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void setWindowFullScreen(bool fullScreen) {
-  HWND target = window();
+void setWindowFullScreen(facebook::react::SurfaceId id, bool fullScreen) {
+  HWND target = window(id);
   if (target == nullptr) {
     return;
   }
@@ -252,7 +275,7 @@ void setWindowFullScreen(bool fullScreen) {
 }
 
 void applyWindowSizeLimits() {
-  HWND target = window();
+  HWND target = win32AppWindow();
   if (target == nullptr) {
     return;
   }
@@ -275,7 +298,7 @@ void applyWindowSizeLimits() {
 }
 
 void setWindowResizable(bool resizable) {
-  HWND target = window();
+  HWND target = win32AppWindow();
   if (target == nullptr) {
     return;
   }
@@ -303,7 +326,7 @@ void setWindowResizable(bool resizable) {
 }
 
 void setWindowAlwaysOnTop(bool alwaysOnTop) {
-  HWND target = window();
+  HWND target = win32AppWindow();
   if (target == nullptr) {
     return;
   }

package/native/win32/Win32WindowModule.cpp

@@ -96,24 +96,19 @@ Win32WindowModule::Win32WindowModule(std::shared_ptr<facebook::react::CallInvoke
   // The window's geometry, the same way the title bar's metrics go out: a
   // device event, so `useWindow()` can hand an app live bounds rather than a
   // snapshot it has to remember to refresh.
-  setWindowBoundsListener([this](const WindowBounds &bounds) {
-    emitDeviceEvent(kWindowBoundsEvent, [bounds](Runtime &runtime, std::vector<Value> &args) {
-      Object object(runtime);
-      object.setProperty(runtime, "x", bounds.x);
-      object.setProperty(runtime, "y", bounds.y);
-      object.setProperty(runtime, "width", bounds.width);
-      object.setProperty(runtime, "height", bounds.height);
-      object.setProperty(runtime, "fullScreen", bounds.fullScreen);
-      object.setProperty(runtime, "maximized", bounds.maximized);
-      args.emplace_back(Value(runtime, object));
-    });
-  });
+  setWindowBoundsListener(
+      [this](facebook::react::SurfaceId window, const WindowBounds &bounds) {
+        emitDeviceEvent(kWindowBoundsEvent,
+                        [window, bounds](Runtime &runtime, std::vector<Value> &args) {
+                          args.emplace_back(windowBoundsPayload(runtime, window, bounds));
+                        });
+      });
 
   // And ask for the bounds once, now that something is listening. The host
   // primes the cache when its window appears, but this module is built lazily
   // -- the first time JavaScript asks for it -- so an app that mounts before
   // then would read a window of no size and never be told otherwise.
-  postToUiThread([] { notifyWindowBoundsChanged(); });
+  postToUiThread([] { notifyWindowBoundsChanged(resolveWindow(kAppWindow)); });
 }
 
 Win32WindowModule::~Win32WindowModule() {