basalt-core 0.0.0-rc5

package/native/core/TitleBarRegions.h

@@ -0,0 +1,31 @@
+// Which parts of an app-drawn header drag the window.
+//
+// `<TitleBar.DragRegion>` and `<TitleBar.NoDragRegion>` mark a view by setting
+// its `nativeID`, because that is the one prop a plain <View> already carries
+// all the way to the host on every platform. It is Electron's
+// `app-region: drag | no-drag`, spelled in something React Native already has.
+//
+// The strings live here rather than in a host because every host that reads
+// them has to read the *same* ones, and JavaScript writes them from a fourth
+// place -- src/TitleBar.tsx, whose comment says they must match. Three copies
+// of a string literal is three chances for a header that silently stops
+// dragging on one desktop, which is a bug nobody notices until they try it.
+//
+// The rule each host applies is the same too, and worth stating once: the
+// deepest view under the point, then each of its ancestors in turn, and the
+// nearest one marked either way decides. So a label inside a drag region drags
+// without being marked, a button inside one stays pressable once it is marked
+// no-drag, and a point under nothing marked is ordinary client area.
+//
+// The hit test itself is per-host -- Win32 walks its own view tree, GTK asks
+// the toolkit with gtk_widget_pick -- because the tree is the toolkit's, not
+// this project's. Only the vocabulary is shared.
+
+#pragma once
+
+namespace basalt {
+
+inline constexpr const char *kTitleBarDragRegionId = "basalt-titlebar-drag";
+inline constexpr const char *kTitleBarNoDragRegionId = "basalt-titlebar-no-drag";
+
+} // namespace basalt

package/native/core/TurboModuleProxy.cpp

@@ -0,0 +1,51 @@
+#include "TurboModuleProxy.h"
+
+#include <glog/logging.h>
+
+#include <string>
+
+namespace basalt {
+
+using facebook::jsi::Function;
+using facebook::jsi::Object;
+using facebook::jsi::PropNameID;
+using facebook::jsi::Runtime;
+using facebook::jsi::Value;
+
+void installTurboModuleProxy(Runtime &runtime) {
+  if (runtime.global().hasProperty(runtime, "__turboModuleProxy")) {
+    // A non-bridgeless runtime installed a real one. Leave it.
+    return;
+  }
+
+  runtime.global().setProperty(
+      runtime,
+      "__turboModuleProxy",
+      Function::createFromHostFunction(
+          runtime,
+          PropNameID::forAscii(runtime, "__turboModuleProxy"),
+          1,
+          [](Runtime &rt, const Value & /*thisVal*/, const Value *args, size_t count) -> Value {
+            if (count < 1 || !args[0].isString()) {
+              return Value::undefined();
+            }
+            const std::string name = args[0].getString(rt).utf8(rt);
+            // `nativeModuleProxy` rather than a captured provider: it is what
+            // NativeModules reads, so this answers for the same set of modules
+            // by construction rather than by being kept in step.
+            const Value proxy = rt.global().getProperty(rt, "nativeModuleProxy");
+            if (!proxy.isObject()) {
+              return Value::undefined();
+            }
+            // Undefined for an unknown name, not an exception: a caller that
+            // asks for a module this platform does not have is the ordinary
+            // case, and `TurboModuleRegistry.get` is allowed to return null.
+            try {
+              return proxy.getObject(rt).getProperty(rt, PropNameID::forUtf8(rt, name));
+            } catch (const facebook::jsi::JSError &) {
+              return Value::undefined();
+            }
+          }));
+}
+
+} // namespace basalt

package/native/core/TurboModuleProxy.h

@@ -0,0 +1,46 @@
+// `globalThis.__turboModuleProxy`, which this platform does not otherwise have.
+//
+// `TurboModuleRegistry.requireModule` asks two things in order:
+//
+//     if (turboModuleProxy != null) { const m = turboModuleProxy(name); if (m) return m; }
+//     const legacy = NativeModules[name]; if (legacy) return legacy;
+//
+// and `TurboModuleBinding::install` installs the first only when `RN$Bridgeless`
+// is absent, and `nativeModuleProxy` -- which is what `NativeModules` reads --
+// otherwise. This platform is bridgeless, so it gets the second and every lookup
+// arrives by the fallback. On the React Native this is built against that is
+// fine: the fallback is unconditional.
+//
+// It is not fine on 0.82 and earlier, where the fallback is gated behind
+// `RN$Bridgeless !== true || RN$TurboInterop === true ||
+// RN$UnifiedNativeModuleProxy === true`, all of which are false here. So on those
+// versions every `getEnforcing` fails, starting with `PlatformConstants`, and an
+// app has to prepend a flag to its own bundle to start at all. React Native's
+// own modules are reached the same way, which is why this is not a niche
+// problem on those versions -- it is all of them.
+//
+// This installs the first question as an alias for the second, so path one
+// succeeds and the gate is never reached:
+//
+//     __turboModuleProxy = name => nativeModuleProxy[name]
+//
+// **An alias rather than a second provider**, which is the point. Writing our own
+// would see only the modules this platform registers and not React Native's, so
+// it would answer null for `PlatformConstants` -- and on the very versions this
+// exists for, a null from path one does not fall through. Delegating means it
+// answers for exactly what the platform can answer for, whoever provides it.
+//
+// Read lazily, at call time, so it does not matter whether `nativeModuleProxy`
+// exists yet when this runs. It does not replace an existing
+// `__turboModuleProxy`: a non-bridgeless runtime has a real one, and this is not
+// better than it.
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace basalt {
+
+void installTurboModuleProxy(facebook::jsi::Runtime &runtime);
+
+} // namespace basalt

package/native/core/UIManagerAccess.cpp

@@ -0,0 +1,43 @@
+#include "UIManagerAccess.h"
+
+namespace basalt {
+
+namespace {
+
+std::weak_ptr<facebook::react::UIManager> &held() {
+  static std::weak_ptr<facebook::react::UIManager> uiManager;
+  return uiManager;
+}
+
+} // namespace
+
+void setSharedUIManager(std::weak_ptr<facebook::react::UIManager> uiManager) {
+  held() = std::move(uiManager);
+}
+
+std::shared_ptr<facebook::react::UIManager> sharedUIManager() {
+  return held().lock();
+}
+
+namespace {
+
+EventListenerInstaller &installer() {
+  static EventListenerInstaller function;
+  return function;
+}
+
+} // namespace
+
+void setEventListenerInstaller(EventListenerInstaller function) {
+  installer() = std::move(function);
+}
+
+bool installEventListener(std::shared_ptr<const facebook::react::EventListener> listener) {
+  if (!installer()) {
+    return false;
+  }
+  installer()(std::move(listener));
+  return true;
+}
+
+} // namespace basalt

package/native/core/UIManagerAccess.h

@@ -0,0 +1,43 @@
+// The UIManager, for the one thing that needs it outside the renderer.
+//
+// Reanimated commits to the shadow tree itself -- that is how an animated style
+// reaches the screen without a React re-render -- so it needs the UIManager,
+// and it is constructed from JavaScript, where no host object is in reach.
+//
+// ReactCxxPlatform already hands the UIManager to the mounting manager through
+// `IMountingManager::setUIManager`, whose default implementation ignores it. So
+// each platform's mounting manager overrides that and puts it here, and the
+// module takes it back out. Weak, because the UIManager belongs to the
+// scheduler and outlives neither a reload nor a quit.
+
+#pragma once
+
+#include <react/renderer/core/EventListener.h>
+#include <react/renderer/uimanager/UIManager.h>
+
+#include <functional>
+
+#include <memory>
+
+namespace basalt {
+
+void setSharedUIManager(std::weak_ptr<facebook::react::UIManager> uiManager);
+std::shared_ptr<facebook::react::UIManager> sharedUIManager();
+
+// Watching every event Fabric dispatches.
+//
+// `Scheduler::addEventListener` is how a library sees events before the
+// components do -- Reanimated needs it so that a scroll handler or a gesture
+// callback declared as a worklet runs on the UI thread rather than a frame
+// later on the JavaScript one. The scheduler belongs to ReactHost, which only
+// the host has, so the host leaves a way to reach it here.
+using EventListenerInstaller =
+    std::function<void(std::shared_ptr<const facebook::react::EventListener>)>;
+
+void setEventListenerInstaller(EventListenerInstaller installer);
+
+// False when no host left one, which is every build that is not a host --
+// the tests and the portability probe.
+bool installEventListener(std::shared_ptr<const facebook::react::EventListener> listener);
+
+} // namespace basalt

package/native/core/WindowBoundsCache.cpp

@@ -0,0 +1,319 @@
+// The last bounds the host reported, readable from any thread.
+//
+// The other half of `notifyWindowBoundsChanged`, and the reason `getBounds()`
+// can answer without a thread hop: a TurboModule method runs on the JavaScript
+// thread, `windowBounds()` may only be called on the UI one, and an app reads
+// bounds during render. A cache the host writes on every change is exact, and
+// the alternative -- blocking the JavaScript thread on a hop to ask the
+// toolkit -- would be a render that waits on a window manager.
+//
+// Deliberately not in each platform's file: the caching is identical in all
+// three and the listener dispatch is what they would each have copied.
+
+#include "WindowControl.h"
+#include "WindowHost.h"
+
+#include <mutex>
+#include <set>
+#include <utility>
+
+namespace basalt {
+
+namespace {
+
+std::mutex &lock() {
+  static std::mutex value;
+  return value;
+}
+
+WindowBounds &cache() {
+  static WindowBounds bounds;
+  return bounds;
+}
+
+std::function<void(const WindowBounds &)> &listener() {
+  static std::function<void(const WindowBounds &)> value;
+  return value;
+}
+
+} // namespace
+
+void setWindowBoundsListener(std::function<void(const WindowBounds &)> value) {
+  const std::lock_guard<std::mutex> guard(lock());
+  listener() = std::move(value);
+}
+
+// --- The displays, changing -------------------------------------------------
+//
+// Only the listener lives here. The list itself is not cached, unlike the
+// window's bounds: bounds are read during render and must not hop, and a
+// display list is read when an app is deciding where to put something, which
+// is rare enough to afford the marshal -- and a stale display list is worse
+// than a slow one, because the thing it is wrong about is whether a screen
+// exists.
+
+std::function<void()> &displaysListener() {
+  static std::function<void()> value;
+  return value;
+}
+
+void setDisplaysListener(std::function<void()> listener) {
+  const std::lock_guard<std::mutex> guard(lock());
+  displaysListener() = std::move(listener);
+}
+
+namespace {
+std::vector<DisplayInfo> &displaysCache() {
+
+  static std::vector<DisplayInfo> value;
+  return value;
+}
+} // namespace
+
+std::vector<DisplayInfo> lastKnownDisplays() {
+  const std::lock_guard<std::mutex> guard(lock());
+  return displaysCache();
+}
+
+void notifyDisplaysChanged() {
+  // Asked on the UI thread, which is where this is called from, and stored
+  // where the JavaScript thread can read it -- exactly what
+  // notifyWindowBoundsChanged does with the window's bounds.
+  //
+  // Which is also why this must be called once at startup and not only on a
+  // change: an app that asks before any monitor has been unplugged should not
+  // get an empty list.
+  std::vector<DisplayInfo> found = displays();
+
+  std::function<void()> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    displaysCache() = std::move(found);
+    toCall = displaysListener();
+  }
+  // Outside the lock, for the reason notifyWindowBoundsChanged gives.
+  if (toCall) {
+    toCall();
+  }
+}
+
+// --- How big it may be ------------------------------------------------------
+//
+// Stored here rather than three times, and stored at all rather than simply
+// handed to the toolkit, because Windows answers WM_GETMINMAXINFO -- a message
+// that arrives whenever the window manager feels like asking, with nowhere to
+// have passed the numbers in.
+
+namespace {
+
+WindowSizeLimits &limits() {
+  static WindowSizeLimits value;
+  return value;
+}
+
+} // namespace
+
+void setWindowMinimumSize(double width, double height) {
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    // Negatives are the same as zero: "no limit". An app clearing a constraint
+    // is more likely to pass 0 than -1, and neither should be a window that
+    // cannot be smaller than minus one pixel.
+    limits().minWidth = width > 0.0 ? width : 0.0;
+    limits().minHeight = height > 0.0 ? height : 0.0;
+  }
+  applyWindowSizeLimits();
+}
+
+void setWindowMaximumSize(double width, double height) {
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    limits().maxWidth = width > 0.0 ? width : 0.0;
+    limits().maxHeight = height > 0.0 ? height : 0.0;
+  }
+  applyWindowSizeLimits();
+}
+
+void constrainToWindowSizeLimits(double &width, double &height) {
+  // `inForce` rather than `limits`, which is the name of the storage next door.
+  const WindowSizeLimits inForce = windowSizeLimits();
+  const WindowCapabilities able = windowCapabilities();
+  if (able.minimumSize) {
+    if (inForce.minWidth > 0.0 && width < inForce.minWidth) {
+      width = inForce.minWidth;
+    }
+    if (inForce.minHeight > 0.0 && height < inForce.minHeight) {
+      height = inForce.minHeight;
+    }
+  }
+  if (able.maximumSize) {
+    if (inForce.maxWidth > 0.0 && width > inForce.maxWidth) {
+      width = inForce.maxWidth;
+    }
+    if (inForce.maxHeight > 0.0 && height > inForce.maxHeight) {
+      height = inForce.maxHeight;
+    }
+  }
+}
+
+WindowSizeLimits windowSizeLimits() {
+  const std::lock_guard<std::mutex> guard(lock());
+  return limits();
+}
+
+WindowBounds lastKnownWindowBounds() {
+  const std::lock_guard<std::mutex> guard(lock());
+  return cache();
+}
+
+void notifyWindowBoundsChanged() {
+  // Asked on the UI thread, which is where this is called from, and stored
+  // where the JavaScript thread can read it.
+  const WindowBounds bounds = windowBounds();
+
+  std::function<void(const WindowBounds &)> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    cache() = bounds;
+    toCall = listener();
+  }
+  // Called outside the lock: it emits a device event, and holding a lock across
+  // a call into the runtime is how a deadlock is built.
+  if (toCall) {
+    toCall(bounds);
+  }
+}
+
+// --- Windows closing themselves ----------------------------------------------
+//
+// Kept here rather than in each host for the same reason the bounds listener
+// is: the storage and the null check are identical in all three, and what
+// differs is only which toolkit notices.
+
+namespace {
+
+std::function<void(facebook::react::SurfaceId)> &closedListener() {
+  static std::function<void(facebook::react::SurfaceId)> value;
+  return value;
+}
+
+// Which windows have an app listening for close attempts, and the listener that
+// tells it about one -- the "refusing to close" half below. Declared up here
+// because `hostWindowClosed` forgets a window's interception on the way out.
+std::set<facebook::react::SurfaceId> &intercepted() {
+  static std::set<facebook::react::SurfaceId> value;
+  return value;
+}
+
+std::function<void(facebook::react::SurfaceId)> &closeRequestListener() {
+  static std::function<void(facebook::react::SurfaceId)> value;
+  return value;
+}
+
+// Quitting is one question about the application rather than one per window,
+// so this is a bool and not a set. See WindowHost.h for why it is a flag at
+// all rather than a callback the system waits on.
+bool &quitIntercepted() {
+  static bool value = false;
+  return value;
+}
+
+std::function<void()> &quitRequestListener() {
+  static std::function<void()> value;
+  return value;
+}
+
+} // namespace
+
+void setHostWindowClosedListener(std::function<void(facebook::react::SurfaceId)> listener) {
+  const std::lock_guard<std::mutex> guard(lock());
+  closedListener() = std::move(listener);
+}
+
+void hostWindowClosed(facebook::react::SurfaceId surfaceId) {
+  std::function<void(facebook::react::SurfaceId)> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    toCall = closedListener();
+    // A window that is gone cannot refuse anything, and leaving its id behind
+    // would mark whichever window is given that surface id next. Surface ids
+    // are not reused today; relying on that would be relying on it.
+    intercepted().erase(surfaceId);
+  }
+  // Outside the lock: it emits a device event, and holding a lock across a call
+  // into the runtime is how a deadlock is built.
+  if (toCall) {
+    toCall(surfaceId);
+  }
+}
+
+// --- Windows refusing to close ----------------------------------------------
+//
+// Here for the same reason as the rest of this file: three hosts would each
+// have written the same set and the same null check, and what differs between
+// them is only which toolkit message means "somebody is trying to close this".
+
+void setHostWindowCloseIntercepted(facebook::react::SurfaceId surfaceId, bool value) {
+  const std::lock_guard<std::mutex> guard(lock());
+  if (value) {
+    intercepted().insert(surfaceId);
+  } else {
+    intercepted().erase(surfaceId);
+  }
+}
+
+bool hostWindowCloseIntercepted(facebook::react::SurfaceId surfaceId) {
+  const std::lock_guard<std::mutex> guard(lock());
+  return intercepted().count(surfaceId) != 0;
+}
+
+void setHostWindowCloseRequestListener(std::function<void(facebook::react::SurfaceId)> listener) {
+  const std::lock_guard<std::mutex> guard(lock());
+  closeRequestListener() = std::move(listener);
+}
+
+// --- The application refusing to quit ---------------------------------------
+//
+// The same shape one level up, and here for the same reason. What differs
+// between the hosts is only which message means "the session is ending":
+// `applicationShouldTerminate:`, `WM_QUERYENDSESSION`, and GTK's session
+// manager.
+
+void setHostQuitIntercepted(bool value) {
+  const std::lock_guard<std::mutex> guard(lock());
+  quitIntercepted() = value;
+}
+
+bool hostQuitIntercepted() {
+  const std::lock_guard<std::mutex> guard(lock());
+  return quitIntercepted();
+}
+
+void setHostQuitRequestListener(std::function<void()> listener) {
+  const std::lock_guard<std::mutex> guard(lock());
+  quitRequestListener() = std::move(listener);
+}
+
+void hostQuitRequested() {
+  std::function<void()> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    toCall = quitRequestListener();
+  }
+  if (toCall) {
+    toCall();
+  }
+}
+
+void hostWindowCloseRequested(facebook::react::SurfaceId surfaceId) {
+  std::function<void(facebook::react::SurfaceId)> toCall;
+  {
+    const std::lock_guard<std::mutex> guard(lock());
+    toCall = closeRequestListener();
+  }
+  if (toCall) {
+    toCall(surfaceId);
+  }
+}
+
+} // namespace basalt