basalt-gtk 0.0.0-rc5

package/native/gtk/GtkScrollView.h

@@ -0,0 +1,209 @@
+// <ScrollView> on GTK4.
+//
+// Yoga does the hard part. A ScrollView's Yoga node carries `overflow: scroll`,
+// which lets its child exceed the viewport instead of being clamped to it, so
+// by the time a mutation arrives the content is already laid out at its full
+// size and the only thing missing is the offset.
+//
+// Structure: a mounted ScrollView has exactly **one** child, a content view.
+// React Native's JS wraps the children in an `RCTScrollContentView`, which the
+// C++ registry rewrites to a plain `View` (`componentNameByReactViewName`), so
+// no extra descriptor is needed and nothing here should expect N children.
+//
+// Scrolling is expressed as an offset on the ScrollView's own RnView rather
+// than by a GtkScrolledWindow. GtkScrolledWindow wants to size its child
+// through the measure/allocate protocol, and this platform's whole invariant is
+// that React Native decides sizes and the layout manager only places things.
+// Shifting children in `RnLayout::allocate` keeps that invariant and makes GTK's
+// hit testing follow the scroll for free.
+//
+// Two things must happen on every scroll, and they are not the same thing:
+//
+//   - `onScroll` goes to JavaScript, throttled by `scrollEventThrottle`. Without
+//     it VirtualizedList never renders past its first window.
+//   - `contentOffset` is written back into `ScrollViewState`, unthrottled.
+//     `ScrollViewShadowNode::getContentOriginOffset` reads it, and through that
+//     so do `measure`, `measureLayout`, C++ hit testing and view culling. Skip
+//     it and those all silently report unscrolled coordinates.
+
+#pragma once
+
+#include "RnView.h"
+#include "ScrollAnimation.h"
+#include "ScrollBounds.h"
+#include "ScrollIndicator.h"
+#include "ScrollSnap.h"
+#include "ScrollMomentum.h"
+
+#include <react/renderer/components/scrollview/ScrollViewShadowNode.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+#include <functional>
+#include <unordered_map>
+
+namespace basalt {
+
+class GtkScrollViewManager {
+ public:
+  // Emitters live in the mounting manager's registry, which is also what owns
+  // this, so they are reached through a lookup rather than a second copy.
+  using EmitterLookup = std::function<facebook::react::EventEmitter::Shared(facebook::react::Tag)>;
+
+  explicit GtkScrollViewManager(EmitterLookup lookup);
+
+  // Called for every mutation touching a ScrollView. Attaches the scroll
+  // controller the first time, and refreshes the geometry and props after.
+  void update(RnView *view, const facebook::react::ShadowView &shadowView);
+
+  void remove(facebook::react::Tag tag);
+
+  // Starts a fling at a velocity in pixels per second, as GTK's `decelerate`
+  // reports one. Returns false if it was too slow to be worth animating.
+  //
+  // Public, and not only because the signal handler is static. The coasting is
+  // otherwise untestable: a real fling needs a touchscreen, and the frame clock
+  // that drives it needs a mapped window and two seconds of main loop. This and
+  // `advanceFling` are the same escape hatch `GtkTouchDispatcher::synthesiseTap`
+  // is, entering exactly where GDK does and skipping nothing above it.
+  bool fling(facebook::react::Tag tag, double velocityX, double velocityY);
+
+  // Advances a running fling by `seconds`, applying the offset and emitting
+  // what falls out of it. Returns false once it has finished, which is also
+  // when onMomentumScrollEnd has been emitted.
+  bool advanceFling(facebook::react::Tag tag, double seconds);
+
+  // Advances an animated `scrollTo` -- or the settle a snapping list does at
+  // the end of a fling -- by `seconds`, returning false once it has arrived.
+  //
+  // Public for the same reason `advanceFling` is: the animation runs on a frame
+  // clock, and a frame clock needs a mapped window and a main loop. Without
+  // this a paging list could be shown to *decide* on a page and never shown to
+  // reach one.
+  bool advanceAnimation(facebook::react::Tag tag, double seconds);
+
+  // ScrollView's imperative commands: scrollTo, scrollToEnd. Returns false if
+  // the command is not one this handles.
+  bool dispatchCommand(facebook::react::Tag tag, const std::string &name, const folly::dynamic &args);
+
+  // A wheel notch carries no pixel distance of its own, so a step has to be
+  // chosen. Roughly three lines of 16pt text, which is what browsers and both
+  // other desktops settle on. Public because the test instrument resolves
+  // notches into pixels before calling `scrollAt`, and the two must use one
+  // number.
+  static constexpr double kWheelStepPixels = 53.0;
+
+  // A wheel over a point, in the surface root's coordinates, for
+  // BASALT_TEST_SCROLL. Returns false when nothing under it scrolls.
+  //
+  // It exists for the same reason every other instrument does: a real wheel
+  // event needs a display server that will deliver one to a window it
+  // considers focused, and an automated run on a headless compositor has no
+  // such thing. This enters where the GtkEventControllerScroll callback does,
+  // so it exercises the hit test, the offset, the clamp, the state write-back,
+  // onScroll and the pull gesture, and skips only GDK's delivery.
+  bool scrollAt(RnView *root, double x, double y, double dx, double dy);
+
+  // The pull past the top of the list, which is what a <RefreshControl> is
+  // waiting for. Called with how far past the top this scroll asked to go, or
+  // with zero when the gesture went the other way or the view actually moved --
+  // which re-arms it. See core/PullToRefresh.h for why a desktop has to count
+  // this rather than measure a rubber band.
+  void setOverscrollTopHandler(std::function<void(facebook::react::Tag, double)> handler) {
+    overscrollTop_ = std::move(handler);
+  }
+
+
+
+ private:
+  std::function<void(facebook::react::Tag, double)> overscrollTop_;
+
+  struct Entry {
+    RnView *view{nullptr};
+    facebook::react::Tag tag{0};
+    GtkScrollViewManager *owner{nullptr};
+
+    // The GTK callbacks below hold a pointer to this Entry. std::unordered_map
+    // never moves its elements, so that pointer stays valid for the life of the
+    // entry -- but erasing one would leave the controller pointing at freed
+    // memory, so remove() detaches the controller first.
+    GtkEventController *controller{nullptr};
+
+    std::shared_ptr<const facebook::react::ScrollViewShadowNode::ConcreteState> state;
+
+    facebook::react::Size contentSize{};
+    facebook::react::Size containerSize{};
+    // `contentInset` changes how far the view scrolls;
+    // `scrollIndicatorInsets` changes only where the bar is drawn. See
+    // core/ScrollBounds.h.
+    facebook::react::EdgeInsets contentInset{};
+    facebook::react::EdgeInsets indicatorInset{};
+
+    bool scrollEnabled{true};
+    // `showsVerticalScrollIndicator` / `showsHorizontalScrollIndicator`. Both
+    // default to true, as React Native's own props do.
+    bool showsVerticalIndicator{true};
+    bool showsHorizontalIndicator{true};
+    // Milliseconds, as React Native's prop is. Zero means every scroll.
+    double eventThrottleMs{0};
+
+    double offsetX{0};
+    double offsetY{0};
+    gint64 lastEmitMicros{0};
+    bool dragging{false};
+
+    // The fling after the fingers left. GTK hands over a velocity and stops, so
+    // the coasting is run here: a tick callback on the view, advancing the
+    // model, until it falls below a pixel a frame or hits an edge.
+    ScrollMomentum momentum;
+    guint momentumTickId{0};
+    // An animated `scrollTo`, which shares the frame clock with the fling above
+    // and never runs at the same time as one: each stops the other.
+    ScrollAnimation animation;
+    guint animationTickId{0};
+    gint64 animationLastMicros{0};
+    gint64 momentumLastMicros{0};
+    // React Native's decelerationRate prop, read off the ScrollView's props so
+    // an app that asks for a fast fling gets one.
+    double decelerationRate{ScrollMomentum::kNormalDeceleration};
+    // `pagingEnabled`, `snapToInterval`, `snapToOffsets`, `snapToAlignment`.
+    ScrollSnapConfig snap;
+  };
+
+  static gboolean onScroll(GtkEventControllerScroll *controller, double dx, double dy, gpointer userData);
+  // The part of onScroll that is not about GTK's event controller, so the test
+  // instrument and a real wheel go through the same code.
+  void scrollEntry(Entry &entry, double dx, double dy);
+  static void onScrollBegin(GtkEventControllerScroll *controller, gpointer userData);
+  static void onScrollEnd(GtkEventControllerScroll *controller, gpointer userData);
+  static void onDecelerate(GtkEventControllerScroll *controller,
+                           double velocityX,
+                           double velocityY,
+                           gpointer userData);
+  static gboolean onMomentumTick(GtkWidget *widget, GdkFrameClock *clock, gpointer userData);
+  static gboolean onAnimationTick(GtkWidget *widget, GdkFrameClock *clock, gpointer userData);
+  void scrollTowards(Entry &entry, double x, double y, bool animated);
+  // Settles a drag or a fling on a snap point, if the props ask for one.
+  // Returns whether it took over.
+  bool settleOnSnapPoint(Entry &entry, double velocityY);
+
+  void stopAnimation(Entry &entry);
+
+  // Ends a fling, with or without telling JavaScript. `emitEnd` is false only
+  // when the ScrollView itself is going away, where the emitter is about to
+  // stop existing anyway.
+  void stopMomentum(Entry &entry, bool emitEnd);
+
+  void applyOffset(Entry &entry, double x, double y, bool emitEvent);
+  // Recomputes both overlay scrollbars and hands them to the view to draw.
+  // Called wherever the offset, the content size or the container size can
+  // have changed, which is more places than the offset alone.
+  void updateIndicators(const Entry &entry);
+  void emitScrollEvent(Entry &entry, const char *which);
+  void writeStateOffset(const Entry &entry);
+
+  EmitterLookup lookup_;
+  std::unordered_map<facebook::react::Tag, Entry> entries_;
+};
+
+} // namespace basalt

package/native/gtk/GtkSkiaContext.cpp

@@ -0,0 +1,248 @@
+#include "GtkSkiaContext.h"
+
+#include "ImageBytes.h"
+#include "PlatformServices.h"
+
+#include <gtk/gtk.h>
+
+#include "include/core/SkData.h"
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkStream.h"
+#include "include/core/SkSurface.h"
+#include "include/core/SkTypeface.h"
+#include "include/ports/SkFontMgr_fontconfig.h"
+#include "include/ports/SkFontScanner_FreeType.h"
+
+#include <glog/logging.h>
+
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace basalt {
+namespace {
+
+class GtkSkiaPlatformContext : public RNSkia::RNSkPlatformContext {
+ public:
+  GtkSkiaPlatformContext(std::shared_ptr<facebook::react::CallInvoker> callInvoker,
+                         float pixelDensity)
+      : RNSkia::RNSkPlatformContext(std::move(callInvoker), pixelDensity) {}
+
+  // ---------------------------------------------------------------- threading
+
+  void runOnMainThread(std::function<void()> func) override {
+    // basalt's own, so Skia's idea of the main thread and this host's are the
+    // same one. Fire and forget, which is all `postToUiThread` offers and all
+    // this seam promises.
+    postToUiThread(std::move(func));
+  }
+
+  // ------------------------------------------------------------------- errors
+
+  void raiseError(const std::exception &err) override {
+    // Logged, not fatal, as on the other two hosts: the package's Apple version
+    // calls RCTFatal and takes the app down with a red box, and a shader that
+    // fails to compile is not a reason to end a session.
+    LOG(ERROR) << "react-native-skia: " << err.what();
+  }
+
+  // ----------------------------------------------------------------- surfaces
+
+  sk_sp<SkSurface> makeOffscreenSurface(int width, int height,
+                                        bool useP3ColorSpace = false) override {
+    // The colour space is accepted and not honoured, as on Windows: a Display
+    // P3 surface is a wide-gamut answer for a host that has no colour
+    // management of its own yet, and silently returning sRGB is the same
+    // picture on a machine that is not wide-gamut.
+    (void)useP3ColorSpace;
+    // CPU. See gtk/GtkSkiaContext.h for why this stage is raster even though
+    // the archives carry a GL backend.
+    return SkSurfaces::Raster(SkImageInfo::MakeN32Premul(width, height));
+  }
+
+  GrDirectContext *getDirectContext() override {
+    // Null is a documented answer rather than a failure: Skia's own call sites
+    // either skip the GPU path for a raster image or say "No GPU context
+    // available" by name. What must not happen is inventing a context that
+    // draws nowhere.
+    return nullptr;
+  }
+
+  // ------------------------------------------------------------------- images
+
+  sk_sp<SkImage> makeImageFromNativeBuffer(void *) override {
+    throw std::runtime_error(unsupportedNativeBuffers());
+  }
+
+  sk_sp<SkImage> makeImageFromNativeTexture(const RNSkia::TextureInfo &, int, int,
+                                            bool) override {
+    throw std::runtime_error(unsupportedTextures());
+  }
+
+  const RNSkia::TextureInfo getTexture(sk_sp<SkImage>) override {
+    throw std::runtime_error(unsupportedTextures());
+  }
+
+  const RNSkia::TextureInfo getTexture(sk_sp<SkSurface>) override {
+    throw std::runtime_error(unsupportedTextures());
+  }
+
+  // -------------------------------------------------------------------- fonts
+
+  sk_sp<SkFontMgr> createFontMgr() override {
+    // Fontconfig, through Skia's own port, which is what the Linux archives are
+    // built with -- the GN args turn it on where the Windows build turns it
+    // off. Same seam, each platform's real font system: CoreText on Apple,
+    // DirectWrite on Windows, this here.
+    //
+    // Two arguments, which is newer than most examples of this call. m152
+    // split the scanner out of the font manager -- `SkFontMgr_New_FontConfig`
+    // used to take a config alone and now takes the thing that reads a font
+    // file as well, because Skia has two of those to choose between: FreeType
+    // and Fontations, its Rust one. FreeType, to match what the archives were
+    // built with.
+    //
+    // A null FcConfig means "the current one", which is fontconfig's own
+    // default -- the machine's /etc/fonts plus the user's. Passing one of our
+    // own would mean owning font discovery, which is not this host's job.
+    //
+    // Made once and shared: this builds a fontconfig configuration each time
+    // it is called, which is a scan of every font directory on the machine,
+    // and createFontMgr is called per paragraph.
+    static sk_sp<SkFontMgr> manager =
+        SkFontMgr_New_FontConfig(nullptr, SkFontScanner_Make_FreeType());
+    return manager;
+  }
+
+  std::vector<std::string> getSystemFontFamilies() override {
+    std::vector<std::string> families;
+    const sk_sp<SkFontMgr> manager = createFontMgr();
+    if (manager == nullptr) {
+      return families;
+    }
+    const int count = manager->countFamilies();
+    families.reserve(static_cast<size_t>(count));
+    for (int i = 0; i < count; i++) {
+      SkString name;
+      manager->getFamilyName(i, &name);
+      families.emplace_back(name.c_str());
+    }
+    return families;
+  }
+
+  // -------------------------------------------------------------------- media
+
+  std::shared_ptr<RNSkia::RNSkVideo> createVideo(const std::string &) override {
+    // The package's video is AVFoundation on Apple and MediaCodec through JNI
+    // on Android; neither exists here. GStreamer is the GTK answer and is its
+    // own piece of work.
+    throw std::runtime_error(
+        "react-native-skia: video is not implemented on this host. It needs "
+        "GStreamer, which nothing here wraps yet.");
+  }
+
+  // ------------------------------------------------------------------ loading
+
+  void performStreamOperation(
+      const std::string &sourceUri,
+      const std::function<void(std::unique_ptr<SkStreamAsset>)> &op) override {
+    // On a thread, because callers treat this as asynchronous and the operation
+    // may read from the network. Detached for the same reason the package's is:
+    // the continuation is the completion.
+    //
+    // Through core's own fetcher rather than a second one written here, so a
+    // URI means to Skia what it means to <Image>: file, data and http, resolved
+    // the same way in both.
+    std::thread([sourceUri, op]() {
+      std::string bytes;
+      std::string error;
+      if (!fetchImageBytes(sourceUri, &bytes, &error)) {
+        LOG(WARNING) << "react-native-skia: could not read " << sourceUri << ": " << error;
+        // An empty stream, not a null one. The continuation in
+        // JsiSkDataFactory::fromURI calls `stream->getLength()` without
+        // checking, so a null here is a segfault rather than a missing image --
+        // and a 404 on one asset would take the app down. Apple's
+        // implementation reaches the same place by accident: a failed
+        // `dataWithContentsOfURL:` leaves `data` nil, and nil's bytes and
+        // length are null and zero, so it too hands over an empty stream.
+        op(SkMemoryStream::Make(SkData::MakeEmpty()));
+        return;
+      }
+      sk_sp<SkData> data = SkData::MakeWithCopy(bytes.data(), bytes.size());
+      op(SkMemoryStream::Make(std::move(data)));
+    }).detach();
+  }
+
+  // ------------------------------------------------- not implemented, and why
+
+  sk_sp<SkImage> takeScreenshotFromViewTag(size_t tag) override {
+    // Needs a tag-to-view lookup and a render of that widget into a surface.
+    // The host has the first half -- the mounting manager keeps a tag registry
+    // -- and nothing yet asks for the second. Named rather than blank: an empty
+    // image here would read as a broken renderer.
+    throw std::runtime_error(
+        "react-native-skia: makeImageSnapshot of a view is not implemented on this "
+        "host (tag " +
+        std::to_string(tag) + "). Render to an offscreen surface instead.");
+  }
+
+  uint64_t makeNativeBuffer(sk_sp<SkImage>) override {
+    throw std::runtime_error(unsupportedNativeBuffers());
+  }
+
+  uint64_t makeTestNativeBuffer(int, int) override {
+    throw std::runtime_error(unsupportedNativeBuffers());
+  }
+
+  void releaseNativeBuffer(uint64_t) override {
+    // Deliberately quiet: nothing here hands out a buffer, so nothing can
+    // return one, and throwing from a release path would turn a leak into a
+    // crash.
+  }
+
+ private:
+  static std::string unsupportedNativeBuffers() {
+    return "react-native-skia: native buffer interchange is not implemented on this "
+           "host. It is used for camera and video frame sharing, which nothing here "
+           "provides yet.";
+  }
+
+  static std::string unsupportedTextures() {
+    return "react-native-skia: this host has no GPU context yet, so there are no "
+           "textures to share. See gtk/GtkSkiaContext.h.";
+  }
+};
+
+} // namespace
+
+std::shared_ptr<RNSkia::RNSkPlatformContext>
+makeSkiaPlatformContext(std::shared_ptr<facebook::react::CallInvoker> callInvoker) {
+  // The default display's scale, and one number for the whole session: Skia
+  // asks for a density up front and there is no window yet when the module
+  // installs. A window dragged to a monitor of another scale is a thing to fix
+  // when something notices, which is the position all three hosts take.
+  //
+  // `gdk_display_get_monitors` needs a display, and there is one by the time a
+  // TurboModule installs -- but not in a test binary that never opened one, so
+  // a missing display is 1.0 rather than a crash.
+  float density = 1.0f;
+  if (GdkDisplay *display = gdk_display_get_default()) {
+    if (GListModel *monitors = gdk_display_get_monitors(display)) {
+      if (auto *monitor = static_cast<GdkMonitor *>(g_list_model_get_item(monitors, 0))) {
+        const int scale = gdk_monitor_get_scale_factor(monitor);
+        if (scale > 0) {
+          density = static_cast<float>(scale);
+        }
+        g_object_unref(monitor);
+      }
+    }
+  }
+  return std::make_shared<GtkSkiaPlatformContext>(std::move(callInvoker), density);
+}
+
+} // namespace basalt

package/native/gtk/GtkSkiaContext.h

@@ -0,0 +1,62 @@
+// What @shopify/react-native-skia needs from the GTK host.
+//
+// `RNSkPlatformContext` is the package's one seam: it hands Skia a runtime, a
+// call invoker and this. The package ships an Apple implementation and an
+// Android one, and neither can stand in here -- the Apple header takes an
+// `RCTBridge *`, and Android's platform context and GL canvas provider are JNI
+// all the way down. So this is basalt's, as appkit/AppKitSkiaContext.h and
+// win32/Win32SkiaContext.h are.
+//
+// ## Raster, for now
+//
+// AppKit's delegates to the package's `MetalContext` and has a GPU context to
+// hand out. This one has none yet: `getDirectContext` answers null and
+// `makeOffscreenSurface` returns a CPU surface.
+//
+// That is a deliberate first stage rather than an oversight, and it is the
+// same stage Windows is at. It is enough for the imperative API -- `Skia.Path`,
+// image decoding, typefaces -- and enough for `<Canvas>`, which renders into
+// one of these surfaces and reaches the screen as a texture; see
+// gtk/GtkSkiaPeer.h.
+//
+// A GPU stage has further to go here than it looks, and further than on the
+// other two. The archives are built `skia_use_gl=true skia_use_egl=true`, so
+// the backend is present, and GTK4 has GtkGLArea. What is missing is the piece
+// in between: Ganesh wants a `GrDirectContext` made from a current GL context,
+// and GtkGLArea only makes one current inside its own render signal -- so the
+// context this class hands out would have to be created and used on GTK's
+// terms rather than on Skia's. That is a real design question, not a port, and
+// it is why this stage is raster.
+//
+// ## Fonts
+//
+// Fontconfig, through Skia's own `SkFontMgr_New_FontConfig`, which is what the
+// Linux archives are built for -- `skia_use_fontconfig=true` and
+// `skia_use_system_freetype2=true` in scripts/build_skia_linux.sh. System
+// freetype rather than a bundled one on purpose: a GTK host already links pango
+// and cairo, which drag in freetype, and two freetypes in one process is a
+// crash rather than an untidiness. The same seam the other two hosts answer
+// with CoreText and DirectWrite.
+//
+// ## No unicode adapter here
+//
+// win32/Win32SkiaUnicode.cpp exists because that host links the libgrapheme
+// backend while the package's JsiSkParagraphBuilder asks for
+// `SkUnicodes::ICU::Make` on anything that is not Apple. This host links
+// skunicode_icu, which defines that name itself -- see the note in
+// cmake/Skia.cmake for why Linux can have the ICU backend and Windows cannot.
+
+#pragma once
+
+#include "RNSkPlatformContext.h"
+
+#include <memory>
+
+namespace basalt {
+
+// The platform context this host gives Skia. One per install; see
+// gtk/GtkSkiaModule.h.
+std::shared_ptr<RNSkia::RNSkPlatformContext>
+makeSkiaPlatformContext(std::shared_ptr<facebook::react::CallInvoker> callInvoker);
+
+} // namespace basalt

package/native/gtk/GtkSkiaModule.cpp

@@ -0,0 +1,80 @@
+#include "GtkSkiaModule.h"
+
+#include "GtkSkiaContext.h"
+
+#include "RNSkManager.h"
+
+#include <glog/logging.h>
+
+#include <memory>
+#include <utility>
+
+namespace basalt {
+namespace {
+
+// The manager outlives the call that made it and owns everything Skia installed
+// into the runtime, so it is held here rather than on the module: a TurboModule
+// is recreated whenever the runtime is, and Skia's bindings are torn down and
+// rebuilt with it.
+//
+// Reset rather than leaked on destruction, which matters for a reload: the
+// bindings hold a jsi::Runtime reference, and keeping them past the runtime
+// they were installed into is how a reload turns into a crash in somebody
+// else's frame.
+std::unique_ptr<RNSkia::RNSkManager> &skManager() {
+  static std::unique_ptr<RNSkia::RNSkManager> manager;
+  return manager;
+}
+
+} // namespace
+
+GtkSkiaModule::GtkSkiaModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)
+    : TurboModule(kModuleName, std::move(jsInvoker)) {
+  // Blocking and synchronous on the JavaScript thread, because the package's
+  // JavaScript calls it and then immediately expects `global.SkiaApi` to be
+  // there. Zero arity, boolean return, matching what NativeSkiaModule declares.
+  methodMap_["install"] = MethodMetadata{0, install};
+}
+
+GtkSkiaModule::~GtkSkiaModule() { skManager().reset(); }
+
+RNSkia::RNSkManager *GtkSkiaModule::manager() { return skManager().get(); }
+
+facebook::jsi::Value GtkSkiaModule::install(facebook::jsi::Runtime &runtime,
+                                            facebook::react::TurboModule &module,
+                                            const facebook::jsi::Value * /*args*/,
+                                            size_t /*count*/) {
+  if (skManager() != nullptr) {
+    // Already installed. The package calls this from module scope and React
+    // Native may evaluate that more than once; a second manager over the same
+    // runtime would install a second set of bindings over the first.
+    return facebook::jsi::Value(true);
+  }
+
+  // Through the derived type: `jsInvoker_` is protected on TurboModule, so a
+  // static member of this class may reach it on a GtkSkiaModule and not on a
+  // TurboModule. The reference is always ours -- the registry only calls this
+  // through the method table filled in above.
+  auto invoker = static_cast<GtkSkiaModule &>(module).jsInvoker_;
+  if (invoker == nullptr) {
+    LOG(ERROR) << "RNSkiaModule: no call invoker, so Skia cannot be installed";
+    return facebook::jsi::Value(false);
+  }
+
+  try {
+    skManager() = std::make_unique<RNSkia::RNSkManager>(
+        &runtime, invoker, makeSkiaPlatformContext(invoker));
+  } catch (const std::exception &error) {
+    // Reported as false rather than thrown, as on the other two hosts: the
+    // package's JavaScript checks the return and says something useful about
+    // it, whereas an exception crossing the JSI boundary during module
+    // initialisation arrives without a stack and without naming Skia.
+    LOG(ERROR) << "RNSkiaModule: install failed: " << error.what();
+    return facebook::jsi::Value(false);
+  }
+
+  LOG(INFO) << "RNSkiaModule: Skia installed";
+  return facebook::jsi::Value(true);
+}
+
+} // namespace basalt

package/native/gtk/GtkSkiaModule.h

@@ -0,0 +1,51 @@
+// `RNSkiaModule`, the TurboModule @shopify/react-native-skia asks for by name.
+//
+// The third of these, and the same shape as appkit/AppKitSkiaModule.h and
+// win32/Win32SkiaModule.h, for the same reason: the package's own module is
+// Objective-C that builds a manager from an `RCTBridge`, and what it actually
+// needs -- a runtime, a call invoker and a platform context -- basalt already
+// has. So the module is ours and the manager is the package's.
+//
+// `install` is where Skia's whole JavaScript API arrives. Constructing
+// RNSkManager installs `SkiaApi` onto the global object, so everything the
+// package's JavaScript reaches for exists from that moment. Until it is called,
+// `getEnforcing('RNSkiaModule')` throws and an app that imports Skia does not
+// start at all.
+//
+// In the gtk package rather than in core, for the reason Skia.cmake gives about
+// the Apple one: a platform context is a host's business. This one reaches
+// fontconfig and GTK's own display, neither of which core has any business
+// knowing about.
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+
+#include "RNSkManager.h"
+
+#include <memory>
+
+namespace basalt {
+
+class GtkSkiaModule : public facebook::react::TurboModule {
+ public:
+  static constexpr const char *kModuleName = "RNSkiaModule";
+
+  explicit GtkSkiaModule(std::shared_ptr<facebook::react::CallInvoker> jsInvoker);
+  ~GtkSkiaModule() override;
+
+  // The manager, or null before `install` has run. A `<Canvas>` registers
+  // itself with it by nativeId, and the lifetime is the runtime's rather than
+  // any one view's, which is why it is reachable here and not owned by a view.
+  static RNSkia::RNSkManager *manager();
+
+ private:
+  // A plain function, because `MethodMetadata::invoker` is a function pointer
+  // rather than a std::function -- a TurboModule's methods are static dispatch.
+  static facebook::jsi::Value install(facebook::jsi::Runtime &runtime,
+                                      facebook::react::TurboModule &module,
+                                      const facebook::jsi::Value *args,
+                                      size_t count);
+};
+
+} // namespace basalt