basalt-core 0.0.0-rc5

package/native/core/WorkletsModule.cpp

@@ -0,0 +1,199 @@
+#include "WorkletsModule.h"
+
+#include "Gestures.h"
+#include "PlatformServices.h"
+
+#include <glog/logging.h>
+
+#ifdef BASALT_HAS_WORKLETS
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/Tools/PlatformLogger.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeBindings.h>
+
+#include <thread>
+#endif
+
+namespace basalt {
+
+bool hasWorklets() {
+#ifdef BASALT_HAS_WORKLETS
+  return true;
+#else
+  return false;
+#endif
+}
+
+#ifdef BASALT_HAS_WORKLETS
+
+namespace {
+
+using facebook::jsi::Runtime;
+using facebook::jsi::Value;
+using facebook::react::TurboModule;
+
+// The thread the bundle runs on, learned at install time -- which happens from
+// JavaScript, so whichever thread that is, is the one. Worklets asks about it
+// to decide whether a job can run now or has to be scheduled.
+std::thread::id &javaScriptThread() {
+  static std::thread::id id;
+  return id;
+}
+
+// The UI thread's scheduler. `postToUiThread` is the platform's, and the base
+// class does the queueing; this only has to get `triggerUI` called over there.
+class DesktopUIScheduler final : public worklets::UIScheduler,
+                                 public std::enable_shared_from_this<DesktopUIScheduler> {
+ public:
+  void scheduleOnUI(std::function<void()> job) override {
+    // Already on the UI thread: run it now rather than a frame later, which is
+    // what makes a gesture handler's worklet feel immediate.
+    if (std::this_thread::get_id() != javaScriptThread()) {
+      job();
+      return;
+    }
+
+    UIScheduler::scheduleOnUI(std::move(job));
+    if (!scheduledOnUI_) {
+      postToUiThread([weakThis = weak_from_this()]() {
+        // The scheduler can be gone by the time this runs -- the runtime it
+        // belongs to is torn down on reload.
+        if (auto self = weakThis.lock()) {
+          self->triggerUI();
+        }
+      });
+    }
+  }
+};
+
+// Held for reanimated, which needs the same proxy rather than a second one, and
+// so that `start()` can reach what `installTurboModule()` made. Weak, because
+// the module owns it and the module goes away with the runtime.
+std::weak_ptr<worklets::WorkletsModuleProxy> &installedProxy() {
+  static std::weak_ptr<worklets::WorkletsModuleProxy> proxy;
+  return proxy;
+}
+
+std::shared_ptr<worklets::WorkletsModuleProxy> &heldProxy() {
+  static std::shared_ptr<worklets::WorkletsModuleProxy> proxy;
+  return proxy;
+}
+
+std::shared_ptr<worklets::RNRuntimeStatus> &runtimeStatus() {
+  static std::shared_ptr<worklets::RNRuntimeStatus> status;
+  return status;
+}
+
+} // namespace
+
+DesktopWorkletsModule::DesktopWorkletsModule(
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  methodMap_["installTurboModule"] = MethodMetadata{1, installTurboModule};
+  methodMap_["start"] = MethodMetadata{0, start};
+  methodMap_["toggleSlowAnimationsOnUIRuntime"] = MethodMetadata{0, toggleSlowAnimations};
+}
+
+DesktopWorkletsModule::~DesktopWorkletsModule() {
+  if (runtimeStatus() != nullptr) {
+    // Tells the worklet runtime that the runtime it was talking to is gone, so
+    // that a job still in flight stops rather than reaching into it.
+    runtimeStatus()->setDead();
+  }
+  heldProxy().reset();
+  installedProxy().reset();
+}
+
+Value DesktopWorkletsModule::installTurboModule(Runtime &runtime,
+                                                TurboModule &module,
+                                                const Value * /*args*/,
+                                                size_t /*count*/) {
+  javaScriptThread() = std::this_thread::get_id();
+
+  auto &self = static_cast<DesktopWorkletsModule &>(module);
+  auto uiScheduler = std::make_shared<DesktopUIScheduler>();
+  runtimeStatus() = std::make_shared<worklets::RNRuntimeStatus>();
+
+  auto runtimeBindings = std::make_shared<worklets::RuntimeBindings>(worklets::RuntimeBindings{
+      // A timer rather than the display's refresh. The display link on each
+      // platform belongs to React Native's own AnimationChoreographer, which
+      // pauses whenever React Native has no animation running -- exactly when a
+      // Reanimated one might be. Sixteen milliseconds is the honest
+      // approximation until there is a frame source both can share; see
+      .requestAnimationFrame =
+          [](std::function<void(const double)> callback) {
+            postDelayed(16, [callback = std::move(callback)]() {
+              callback(monotonicMilliseconds());
+            });
+          },
+      // Only used in bundle mode, which this is not.
+      .nativeLoggingHook = {},
+  });
+
+  auto proxy = std::make_shared<worklets::WorkletsModuleProxy>(
+      runtime,
+      self.jsInvoker_,
+      uiScheduler,
+      []() -> bool { return std::this_thread::get_id() == javaScriptThread(); },
+      runtimeBindings,
+      worklets::BundleModeConfig{.enabled = false, .script = nullptr, .sourceURL = ""},
+      runtimeStatus());
+
+  heldProxy() = proxy;
+  installedProxy() = proxy;
+  return Value(true);
+}
+
+Value DesktopWorkletsModule::start(Runtime & /*runtime*/,
+                                   TurboModule & /*module*/,
+                                   const Value * /*args*/,
+                                   size_t /*count*/) {
+  if (auto proxy = installedProxy().lock()) {
+    proxy->start();
+    return Value(true);
+  }
+  return Value(false);
+}
+
+Value DesktopWorkletsModule::toggleSlowAnimations(Runtime & /*runtime*/,
+                                                  TurboModule & /*module*/,
+                                                  const Value * /*args*/,
+                                                  size_t /*count*/) {
+  // A developer-menu affordance; iOS throws here for the same reason.
+  LOG(WARNING) << "worklets: slow animations are not supported on this platform";
+  return Value(false);
+}
+
+#endif
+
+} // namespace basalt
+
+#ifdef BASALT_HAS_WORKLETS
+// The logging seam worklets' C++ declares and leaves to each platform: Android
+// writes to logcat, Apple to os_log, and this to the same place every other log
+// line in this project goes.
+namespace worklets {
+
+void PlatformLogger::log(const char *str) {
+  LOG(INFO) << "[worklets] " << str;
+}
+
+void PlatformLogger::log(const std::string &str) {
+  LOG(INFO) << "[worklets] " << str;
+}
+
+void PlatformLogger::log(const double d) {
+  LOG(INFO) << "[worklets] " << d;
+}
+
+void PlatformLogger::log(const int i) {
+  LOG(INFO) << "[worklets] " << i;
+}
+
+void PlatformLogger::log(const bool b) {
+  LOG(INFO) << "[worklets] " << (b ? "true" : "false");
+}
+
+} // namespace worklets
+#endif

package/native/core/WorkletsModule.h

@@ -0,0 +1,57 @@
+// react-native-worklets, which is what Reanimated 4 is built on.
+//
+// The package ships its portable half as C++ in `Common/cpp` -- a second
+// JavaScript runtime for the UI thread, the serialisation that gets a function
+// into it, the schedulers between the two -- depending on jsi, Hermes, a call
+// invoker and nothing else. So it compiles here unmodified, at the app's own
+// version, the same arrangement expo-modules-core has. See cmake/Worklets.cmake.
+//
+// What the package does not ship for a desktop is the host half, and this is
+// it: the TurboModule its JavaScript looks up, a UI scheduler, a frame source,
+// and the platform logger its C++ declares and leaves to each platform.
+//
+// The whole of the port is those four things, which is worth saying plainly:
+// the hard part of worklets -- a separate Hermes runtime, capturing a closure
+// across it, keeping shared values coherent between two runtimes -- is written
+// once, portably, by the people who wrote it. A platform contributes a thread
+// to run on and a heartbeat.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+
+namespace basalt {
+
+// Whether this build has react-native-worklets compiled into it, for the log
+// line that tells a developer which of the two situations they are in.
+bool hasWorklets();
+
+#ifdef BASALT_HAS_WORKLETS
+
+class DesktopWorkletsModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "WorkletsModule";
+
+  explicit DesktopWorkletsModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~DesktopWorkletsModule() override;
+
+ private:
+  static facebook::jsi::Value installTurboModule(facebook::jsi::Runtime &runtime,
+                                                 facebook::react::TurboModule &module,
+                                                 const facebook::jsi::Value *args,
+                                                 size_t count);
+  static facebook::jsi::Value start(facebook::jsi::Runtime &runtime,
+                                    facebook::react::TurboModule &module,
+                                    const facebook::jsi::Value *args,
+                                    size_t count);
+  static facebook::jsi::Value toggleSlowAnimations(facebook::jsi::Runtime &runtime,
+                                                   facebook::react::TurboModule &module,
+                                                   const facebook::jsi::Value *args,
+                                                   size_t count);
+};
+
+#endif
+
+} // namespace basalt

package/native/core/portability_probe.cpp

@@ -0,0 +1,210 @@
+// Does the shared core actually stand on its own?
+//
+// `basalt_core` compiles without a toolkit on the include path, which says
+// nothing about whether it *links* without one. A header that is never included
+// cannot betray you; an undefined symbol at link time can.
+//
+// So this is a program that links the core and nothing platform-specific, and
+// touches each module the core provides. If it links, a new desktop platform
+// can build the core as-is. If it does not, the missing symbols are exactly the
+// list of what that platform has to implement -- which is the more useful
+// outcome of the two, and the reason this prints them rather than asserting.
+//
+// It is not a test of behaviour. It never constructs a runtime and never
+// renders anything. It answers one question: what does a second platform owe?
+//
+// What it deliberately does not include is any capability package's header.
+// A package's core half is compiled into `basalt_core`, so its seam is a
+// symbol this has to satisfy -- but an app installs the packages it wants and
+// core has to compile in one that installed none. So a package brings its own
+// stub, through BASALT_PACKAGE_PROBE_SOURCES; see
+// packages/basalt-notifications/native/probe_stub.cpp. Including
+// one here made core fail to compile in an app without that package, and the
+// failure read as a missing file in core rather than as a dependency core
+// should never have had.
+
+#include "AppearanceModule.h"
+#include "ColorScheme.h"
+#include "CoreModules.h"
+#include "ComponentRegistry.h"
+#include "ExpoRuntime.h"
+#include "FontRegistry.h"
+#include "PlatformConstantsModule.h"
+#include "SourceCodeModule.h"
+#include "PlatformServices.h"
+#include "MenuModel.h"
+#include "WindowControl.h"
+#include "WindowHost.h"
+#include "StatusBarModule.h"
+#include "WorkletsModule.h"
+
+#include <cstdio>
+#include <string>
+#include <vector>
+
+// The seam, stubbed, so that the link answers the question fully rather than
+// stopping at the first thing missing. A real platform implements these against
+// fontconfig, Core Text or DirectWrite; a platform that has not yet gets this
+// far and no further, which is the point.
+namespace basalt {
+bool registerFont(const std::string &, const std::string &) {
+  return false;
+}
+std::string resolveFontFamily(const std::string &name) {
+  return name;
+}
+bool isFontRegistered(const std::string &) {
+  return false;
+}
+unsigned long fontGeneration() {
+  return 0;
+}
+std::string registeredFontNamesJoined(char) {
+  return {};
+}
+
+// The colour-scheme seam, stubbed the same way. A real platform answers from
+// NSAppearance, GtkSettings or the Windows registry; one that has not yet gets
+// this far and no further.
+ColorScheme systemColorScheme() {
+  return ColorScheme::Light;
+}
+void startObservingColorScheme() {}
+
+// The platform-services seam, stubbed the same way: clipboard, opening a URL
+// and showing a dialog are the three things a core module cannot do alone.
+std::string clipboardText() {
+  return {};
+}
+void setClipboardText(const std::string &) {}
+bool canOpenUrl(const std::string &) {
+  return false;
+}
+bool openUrl(const std::string &) {
+  return false;
+}
+void showAlert(const AlertRequest &, AlertCallback) {}
+// A file dialog and a share sheet, stubbed the same way. Both answer "the person
+// cancelled", which is what a platform that cannot ask them should say.
+//
+// Missing here until a capability package called one. The probe only ever sees
+// the symbols something in core's link closure *references*, and nothing in core
+// reached these two -- the dialog module and the share module are both only
+// reachable from a host. So the seam was one a new port owed and the probe did
+// not say so, which is the one thing this file exists to prevent.
+void showFileDialog(const FileDialogRequest &, FileDialogCallback onDone) {
+  if (onDone) {
+    onDone(true, {});
+  }
+}
+void shareContent(const ShareRequest &, ShareCallback onDone) {
+  if (onDone) {
+    onDone(ShareOutcome::Dismissed, {});
+  }
+}
+// A popup menu, stubbed the same way. Answering -1 is the seam's "dismissed",
+// which is the honest reply from a platform that cannot show one.
+void showMenu(const MenuRequest &, MenuCallback onChosen) {
+  if (onChosen) {
+    onChosen(-1);
+  }
+}
+// Added when the gesture recognisers arrived: "run this on the UI thread", now
+// and later. A platform with a run loop has both already; this one has neither
+// and says so.
+// The window seam, stubbed the same way. A real platform answers from a
+// GtkWindow, an NSWindow or an HWND; one that has not yet reports a window of
+// no size, which is what an app reading bounds before there is one sees.
+WindowBounds windowBounds() {
+  return {};
+}
+void setWindowSize(double, double) {}
+void setWindowPosition(double, double) {}
+void centerWindow() {}
+void setWindowFullScreen(bool) {}
+void applyWindowSizeLimits() {}
+void setWindowResizable(bool) {}
+void setWindowAlwaysOnTop(bool) {}
+WindowCapabilities windowCapabilities() {
+  // A platform with no window manager does none of them, which is the honest
+  // answer rather than a convenient one: this probe exists to say what a new
+  // port owes, and four falses is the starting position.
+  return WindowCapabilities{};
+}
+
+// The application menu, stubbed the same way. A platform with no menu bar
+// answers exactly this, which is also what GTK answers for real.
+bool applicationMenuSupported() {
+  return false;
+}
+void setApplicationMenu(const MenuModel &, std::function<void(int)>) {}
+std::string describeApplicationMenu() {
+  return {};
+}
+
+// The window seam's other half: opening one. A platform that cannot answers
+// zero, which every caller reads as "no window was opened".
+facebook::react::SurfaceId openHostWindow(const NewWindowOptions &) {
+  return 0;
+}
+void closeHostWindow(facebook::react::SurfaceId) {}
+std::vector<facebook::react::SurfaceId> hostWindows() {
+  return {};
+}
+
+void postDelayed(double, std::function<void()>) {}
+void postToUiThread(std::function<void()>) {}
+bool isUiThread() {
+  return false;
+}
+} // namespace basalt
+
+int main() {
+  using basalt::DesktopPlatformConstantsModule;
+  using basalt::DesktopAccessibilityInfoModule;
+  using basalt::DesktopAlertModule;
+  using basalt::DesktopAppearanceModule;
+  using basalt::DesktopClipboardModule;
+  using basalt::DesktopI18nManagerModule;
+  using basalt::DesktopLinkingModule;
+  using basalt::DesktopSourceCodeModule;
+  using basalt::DesktopStatusBarModule;
+
+  // Each of these is a symbol the linker must find in the core alone.
+  const std::string url =
+      basalt::scriptURLFor("bundle.js", false, "localhost", 8081, "index", "probe");
+  const bool expo = basalt::hasExpoRuntime();
+  const bool worklets = basalt::hasWorklets();
+
+  // The seams: declared by the core, implemented by a platform. On a platform
+  // that has not implemented them, the link fails here and names them.
+  const bool registered = basalt::isFontRegistered("nothing");
+  const unsigned long generation = basalt::fontGeneration();
+  const char *scheme = basalt::colorSchemeName(basalt::effectiveColorScheme());
+
+  // Named so the link has to find each module the core claims to provide.
+  std::printf("core links.\n");
+  // Named so the link has to find each module the core claims to provide.
+  std::printf("  modules           %s, %s, %s, %s,\n",
+              std::string(DesktopPlatformConstantsModule::kModuleName).c_str(),
+              std::string(DesktopSourceCodeModule::kModuleName).c_str(),
+              std::string(DesktopStatusBarModule::kModuleName).c_str(),
+              std::string(DesktopAppearanceModule::kModuleName).c_str());
+  std::printf("                    %s, %s, %s, %s, %s\n",
+              std::string(DesktopClipboardModule::kModuleName).c_str(),
+              std::string(DesktopAlertModule::kModuleName).c_str(),
+              std::string(DesktopLinkingModule::kModuleName).c_str(),
+              std::string(DesktopI18nManagerModule::kModuleName).c_str(),
+              std::string(DesktopAccessibilityInfoModule::kModuleName).c_str());
+  std::printf("  scriptURLFor      %s\n", url.c_str());
+  std::printf("  expo runtime      %s\n", expo ? "compiled in" : "not compiled in");
+  std::printf("  worklets          %s\n", worklets ? "compiled in" : "not compiled in");
+  std::printf("  font seam         isFontRegistered=%d generation=%lu\n",
+              registered ? 1 : 0,
+              generation);
+  std::printf("  colour scheme     %s\n", scheme);
+  std::printf("  services seam     canOpenUrl=%d clipboard=\"%s\"\n",
+              basalt::canOpenUrl("https://example.com") ? 1 : 0,
+              basalt::clipboardText().c_str());
+  return 0;
+}

package/native/tests/EventRecorder.h

@@ -0,0 +1,124 @@
+// A place for a unit test to watch events arrive.
+//
+// Neither host suite could see an event. The managers ask
+// `eventEmitterForTag` for an emitter and call `onChange`, `onFocus`,
+// `onKeyPress` on it, and the shadow views the tests hand-build carry no
+// emitter at all -- so `test_appkit_textinput.mm` says, accurately, that what
+// it pins is "that the round trip did not throw". Nothing below the
+// end-to-end suite knew whether an event fired, let alone in what order.
+//
+// ## Why there is no stub emitter here
+//
+// The obvious fix is a fake emitter handed back through the lookup, and it
+// cannot work: `TextInputEventEmitter` contains the word `virtual` zero
+// times, so there is nothing to override. Every `onX` calls the non-virtual
+// `EventEmitter::dispatchEvent`, which locks a `weak_ptr<const
+// EventDispatcher>` and returns quietly when it is empty. That empty weak
+// pointer is exactly the state the suites were in.
+//
+// ## So this builds the real thing instead
+//
+// `EventDispatcher` offers a listener -- `std::function<bool(const RawEvent
+// &)>` -- and consults it at the top of `dispatchEvent`, before the logger and
+// before the queue. Returning true says the event was handled and stops the
+// default dispatch, so nothing downstream ever runs and no beat is needed to
+// flush anything.
+//
+// The one awkward piece is that `EventQueue`'s constructor calls
+// `setBeatCallback` on the beat immediately, so it cannot be null, and
+// `EventBeat` holds a `RuntimeScheduler &`. That sounds like the whole JS
+// machinery and is not: `RuntimeScheduler` takes a `RuntimeExecutor`, which is
+// a `std::function`, and a runtime only appears when something invokes it.
+// Nothing here does.
+//
+// ## What can be asserted, and what cannot
+//
+// Event *types* and their *order*, which is what the payload-free half of an
+// event is. Payload values cannot: `TextInputEventEmitter` builds a
+// `jsi::Object` through a `ValueFactory`, and reading one back needs a
+// `jsi::Runtime` -- which is the machinery these suites exist to avoid. What
+// a value ends up as is the end-to-end suite's to check; that the event fired
+// at all, and before or after its neighbour, is this one's.
+
+#pragma once
+
+#include <react/renderer/core/EventDispatcher.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/EventListener.h>
+#include <react/renderer/core/EventQueueProcessor.h>
+#include <react/renderer/core/RawEvent.h>
+#include <react/renderer/runtimescheduler/RuntimeScheduler.h>
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace basalt::testing {
+
+// An EventBeat that never beats. `EventQueue` requires one and this test never
+// reaches the queue, so what matters is that it exists and does nothing.
+class IdleEventBeat : public facebook::react::EventBeat {
+ public:
+  IdleEventBeat(std::shared_ptr<OwnerBox> ownerBox,
+                facebook::react::RuntimeScheduler &scheduler)
+      : EventBeat(std::move(ownerBox), scheduler) {}
+
+  void request() const override {}
+};
+
+class EventRecorder {
+ public:
+  EventRecorder()
+      : scheduler_([](std::function<void(facebook::jsi::Runtime &)> &&) {}),
+        dispatcher_(std::make_shared<const facebook::react::EventDispatcher>(
+            facebook::react::EventQueueProcessor(nullptr, nullptr, nullptr, {}),
+            std::make_unique<IdleEventBeat>(
+                std::make_shared<facebook::react::EventBeat::OwnerBox>(), scheduler_),
+            [](const facebook::react::StateUpdate &) {},
+            std::weak_ptr<facebook::react::EventLogger>{})),
+        listener_(std::make_shared<const facebook::react::EventListener>(
+            [this](const facebook::react::RawEvent &event) {
+              std::scoped_lock lock(mutex_);
+              seen_.push_back(event.type);
+              // Handled: the event stops here rather than going on to a queue
+              // that would need a JavaScript thread to drain it.
+              return true;
+            })) {
+    dispatcher_->addListener(listener_);
+  }
+
+  // An emitter of the kind a manager will look for. The event target is null,
+  // which `EventEmitter::dispatchEvent` moves into the `RawEvent` without
+  // touching -- a tag is not what is being asserted here.
+  // Non-const, because that is what `ShadowView::eventEmitter` is at this
+  // React Native. Every `onX` is a const method, so it makes no difference to
+  // the caller.
+  template <typename Emitter>
+  std::shared_ptr<Emitter> emitter() const {
+    return std::make_shared<Emitter>(nullptr, dispatcher_);
+  }
+
+  // The event types seen so far, in the order they were dispatched. Names are
+  // React Native's own normalised spelling: see `normalizeEventType`.
+  std::vector<std::string> seen() const {
+    std::scoped_lock lock(mutex_);
+    return seen_;
+  }
+
+  void clear() {
+    std::scoped_lock lock(mutex_);
+    seen_.clear();
+  }
+
+ private:
+  facebook::react::RuntimeScheduler scheduler_;
+  std::shared_ptr<const facebook::react::EventDispatcher> dispatcher_;
+  std::shared_ptr<const facebook::react::EventListener> listener_;
+  mutable std::mutex mutex_;
+  std::vector<std::string> seen_;
+};
+
+} // namespace basalt::testing