one 2.10.0 → 2.11.1

package/linux/host/OneLinuxPointer.cpp

@@ -0,0 +1,373 @@
+#include "OneLinuxPointer.h"
+
+#include <react/renderer/components/view/TouchEventEmitter.h>
+#include <react/timing/primitives.h>
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace facebook::react {
+
+namespace {
+
+// GTK takes CSS cursor names, which are what the style names come from
+const char *cursorName(Cursor cursor)
+{
+  switch (cursor) {
+    case Cursor::Alias: return "alias";
+    case Cursor::AllScroll: return "all-scroll";
+    case Cursor::Cell: return "cell";
+    case Cursor::ColResize: return "col-resize";
+    case Cursor::ContextMenu: return "context-menu";
+    case Cursor::Copy: return "copy";
+    case Cursor::Crosshair: return "crosshair";
+    case Cursor::EResize: return "e-resize";
+    case Cursor::EWResize: return "ew-resize";
+    case Cursor::Grab: return "grab";
+    case Cursor::Grabbing: return "grabbing";
+    case Cursor::Help: return "help";
+    case Cursor::Move: return "move";
+    case Cursor::NEResize: return "ne-resize";
+    case Cursor::NESWResize: return "nesw-resize";
+    case Cursor::NResize: return "n-resize";
+    case Cursor::NSResize: return "ns-resize";
+    case Cursor::NWResize: return "nw-resize";
+    case Cursor::NWSEResize: return "nwse-resize";
+    case Cursor::NoDrop: return "no-drop";
+    case Cursor::None: return "none";
+    case Cursor::NotAllowed: return "not-allowed";
+    case Cursor::Pointer: return "pointer";
+    case Cursor::Progress: return "progress";
+    case Cursor::RowResize: return "row-resize";
+    case Cursor::SResize: return "s-resize";
+    case Cursor::SEResize: return "se-resize";
+    case Cursor::SWResize: return "sw-resize";
+    case Cursor::Text: return "text";
+    case Cursor::WResize: return "w-resize";
+    case Cursor::Wait: return "wait";
+    case Cursor::ZoomIn: return "zoom-in";
+    case Cursor::ZoomOut: return "zoom-out";
+    case Cursor::Auto:
+    case Cursor::Default:
+    case Cursor::Url: return "default";
+  }
+  return "default";
+}
+
+} // namespace
+
+OneLinuxPointerHandler::OneLinuxPointerHandler(OneView *surface, Describe describe, EmitterFor emitterFor, ViewFor viewFor)
+    : surface_(surface), describe_(std::move(describe)), emitterFor_(std::move(emitterFor)), viewFor_(std::move(viewFor))
+{
+  // capture phase and never claims the event, so controls inside a view (the
+  // switch) still get their own clicks
+  controller_ = gtk_event_controller_legacy_new();
+  gtk_event_controller_set_propagation_phase(controller_, GTK_PHASE_CAPTURE);
+  g_signal_connect(controller_, "event", G_CALLBACK(onEvent), this);
+  gtk_widget_add_controller(GTK_WIDGET(surface_), controller_);
+}
+
+OneLinuxPointerHandler::~OneLinuxPointerHandler()
+{
+  g_signal_handlers_disconnect_by_data(controller_, this);
+  g_object_ref(controller_);
+  gtk_widget_remove_controller(GTK_WIDGET(surface_), controller_);
+  g_object_unref(controller_);
+}
+
+gboolean OneLinuxPointerHandler::onEvent(GtkEventControllerLegacy *, GdkEvent *event, gpointer data)
+{
+  return static_cast<OneLinuxPointerHandler *>(data)->handle(event);
+}
+
+OneView *OneLinuxPointerHandler::hitChildren(
+    OneView *parent,
+    double x,
+    double y,
+    OneLinuxPointerTarget &target,
+    double &localX,
+    double &localY)
+{
+  if (auto *content = one_view_get_navigation_content(parent)) {
+    graphene_point_t source{static_cast<float>(x), static_cast<float>(y)}, point;
+    if (gtk_widget_compute_point(GTK_WIDGET(parent), GTK_WIDGET(content), &source, &point)) {
+      return hitTest(content, point.x, point.y, target, localX, localY);
+    }
+    return nullptr;
+  }
+  GtkWidget *control = one_view_get_control(parent);
+  for (GtkWidget *child = gtk_widget_get_last_child(GTK_WIDGET(parent)); child; child = gtk_widget_get_prev_sibling(child)) {
+    if (child == control) {
+      continue;
+    }
+    OneView *childView = ONE_VIEW(child);
+    double childX, childY;
+    if (!one_view_map_from_parent(childView, x, y, &childX, &childY)) {
+      continue;
+    }
+    if (OneView *hit = hitTest(childView, childX, childY, target, localX, localY)) {
+      return hit;
+    }
+  }
+  return nullptr;
+}
+
+OneView *OneLinuxPointerHandler::hitTest(
+    OneView *view,
+    double x,
+    double y,
+    OneLinuxPointerTarget &target,
+    double &localX,
+    double &localY)
+{
+  double frameX, frameY, width, height;
+  one_view_get_frame(view, &frameX, &frameY, &width, &height);
+  OneLinuxPointerTarget self{};
+  // the surface view holds the root but is no React view
+  bool known = describe_(view, self);
+  bool inside = !known || (x >= 0 && y >= 0 && x < width && y < height);
+
+  PointerEventsMode mode = known ? self.pointerEvents : PointerEventsMode::Auto;
+  if (mode == PointerEventsMode::None) {
+    return nullptr;
+  }
+
+  if (mode != PointerEventsMode::BoxOnly && (inside || (!one_view_get_clips(view) && !one_view_get_scroll_content(view)))) {
+    if (OneView *content = one_view_get_scroll_content(view)) {
+      double scrollX, scrollY;
+      one_view_get_scroll_offset(view, &scrollX, &scrollY);
+      if (OneView *hit = hitChildren(content, x + scrollX, y + scrollY, target, localX, localY)) {
+        return hit;
+      }
+    } else if (OneView *hit = hitChildren(view, x, y, target, localX, localY)) {
+      return hit;
+    }
+  }
+
+  if (known && inside && mode != PointerEventsMode::BoxNone) {
+    target = self;
+    localX = x;
+    localY = y;
+    return view;
+  }
+  return nullptr;
+}
+
+// a window point in the coordinates of the view with `tag`: down from the
+// surface through each view's frame and transform, plus the scroll offset where
+// the step enters a scroll view's content, the same steps hit testing takes
+bool OneLinuxPointerHandler::localPoint(Tag tag, double x, double y, double &localX, double &localY)
+{
+  OneView *view = viewFor_(tag);
+  if (!view) {
+    return false;
+  }
+  std::vector<OneView *> path;
+  for (GtkWidget *widget = GTK_WIDGET(view); widget && widget != GTK_WIDGET(surface_); widget = gtk_widget_get_parent(widget)) {
+    if (ONE_IS_VIEW(widget)) {
+      path.push_back(ONE_VIEW(widget));
+    }
+  }
+  OneView *parent = surface_;
+  for (auto step = path.rbegin(); step != path.rend(); ++step) {
+    if (one_view_get_navigation_content(parent) == *step) {
+      graphene_point_t source{static_cast<float>(x), static_cast<float>(y)}, point;
+      if (!gtk_widget_compute_point(GTK_WIDGET(parent), GTK_WIDGET(*step), &source, &point)) return false;
+      x = point.x;
+      y = point.y;
+    } else if (one_view_get_scroll_content(parent) == *step) {
+      double scrollX, scrollY;
+      one_view_get_scroll_offset(parent, &scrollX, &scrollY);
+      x += scrollX;
+      y += scrollY;
+    } else if (!one_view_map_from_parent(*step, x, y, &x, &y)) {
+      return false;
+    }
+    parent = *step;
+  }
+  localX = x;
+  localY = y;
+  return true;
+}
+
+void OneLinuxPointerHandler::sendPointer(Tag tag, const char *type, double x, double y, int button)
+{
+  auto emitter = std::static_pointer_cast<const TouchEventEmitter>(emitterFor_(tag));
+  if (!emitter) {
+    return;
+  }
+  PointerEvent event{};
+  event.pointerId = 1;
+  event.pointerType = "mouse";
+  event.pressure = touching_ ? 0.5f : 0.0f;
+  event.clientPoint = {static_cast<Float>(x), static_cast<Float>(y)};
+  event.screenPoint = event.clientPoint;
+  double localX = x, localY = y;
+  localPoint(tag, x, y, localX, localY);
+  event.offsetPoint = {static_cast<Float>(localX), static_cast<Float>(localY)};
+  event.width = 1;
+  event.height = 1;
+  event.buttons = touching_ ? 1 : 0;
+  event.button = button;
+  event.shiftKey = modifiers_ & GDK_SHIFT_MASK;
+  event.ctrlKey = modifiers_ & GDK_CONTROL_MASK;
+  event.altKey = modifiers_ & GDK_ALT_MASK;
+  event.metaKey = modifiers_ & GDK_META_MASK;
+  event.isPrimary = true;
+  event.timeStamp = HighResTimeStamp::now();
+  if (!std::strcmp(type, "leave")) {
+    emitter->onPointerLeave(std::move(event));
+  } else if (!std::strcmp(type, "down")) {
+    emitter->onPointerDown(std::move(event));
+  } else if (!std::strcmp(type, "move")) {
+    emitter->onPointerMove(std::move(event));
+  } else if (!std::strcmp(type, "up")) {
+    emitter->onPointerUp(std::move(event));
+  } else if (!std::strcmp(type, "cancel")) {
+    emitter->onPointerCancel(std::move(event));
+  }
+}
+
+// react native synthesizes hover transitions from moves at the current target
+// and a single leave when the mouse leaves the surface
+void OneLinuxPointerHandler::updateHover(double x, double y, bool inside)
+{
+  Cursor cursor = Cursor::Auto;
+  if (inside) {
+    OneLinuxPointerTarget target{};
+    double localX = 0, localY = 0;
+    if (OneView *hit = hitTest(surface_, x, y, target, localX, localY)) {
+      hoverTarget_ = target.tag;
+      sendPointer(target.tag, "move", x, y);
+      for (GtkWidget *widget = GTK_WIDGET(hit); widget && cursor == Cursor::Auto; widget = gtk_widget_get_parent(widget)) {
+        OneLinuxPointerTarget ancestor{};
+        if (ONE_IS_VIEW(widget) && describe_(ONE_VIEW(widget), ancestor)) {
+          cursor = ancestor.cursor;
+        }
+      }
+    } else if (hoverTarget_) {
+      sendPointer(hoverTarget_, "leave", x, y);
+      hoverTarget_ = 0;
+    }
+  } else if (hoverTarget_) {
+    sendPointer(hoverTarget_, "leave", x, y);
+    hoverTarget_ = 0;
+  }
+  if (cursor != cursor_) {
+    cursor_ = cursor;
+    gtk_widget_set_cursor_from_name(GTK_WIDGET(surface_), cursorName(cursor));
+  }
+}
+
+void OneLinuxPointerHandler::send(const char *phase, double x, double y, bool stillDown)
+{
+  auto emitter = std::static_pointer_cast<const TouchEventEmitter>(emitterFor_(touchTarget_));
+  if (!emitter) {
+    return;
+  }
+  Touch touch;
+  touch.target = touchTarget_;
+  touch.pagePoint = {static_cast<Float>(x), static_cast<Float>(y)};
+  double localX = x, localY = y;
+  localPoint(touchTarget_, x, y, localX, localY);
+  touch.offsetPoint = {static_cast<Float>(localX), static_cast<Float>(localY)};
+  // wayland gives clients no global position, so the screen point is the window point
+  touch.screenPoint = touch.pagePoint;
+  touch.identifier = 0;
+  touch.force = stillDown ? 1.0f : 0.0f;
+  touch.timestamp = static_cast<Float>(g_get_monotonic_time() / 1e6);
+  touch.timeStamp = HighResTimeStamp::now();
+
+  TouchEvent event;
+  event.changedTouches.insert(touch);
+  if (stillDown) {
+    event.touches.insert(touch);
+    event.targetTouches.insert(touch);
+  }
+  if (!std::strcmp(phase, "start")) {
+    emitter->onTouchStart(std::move(event));
+  } else if (!std::strcmp(phase, "move")) {
+    emitter->onTouchMove(std::move(event));
+  } else if (!std::strcmp(phase, "end")) {
+    emitter->onTouchEnd(std::move(event));
+  } else {
+    emitter->onTouchCancel(std::move(event));
+  }
+}
+
+bool OneLinuxPointerHandler::handle(GdkEvent *event)
+{
+  GdkEventType type = gdk_event_get_event_type(event);
+  if (type != GDK_BUTTON_PRESS && type != GDK_BUTTON_RELEASE && type != GDK_MOTION_NOTIFY && type != GDK_GRAB_BROKEN &&
+      type != GDK_ENTER_NOTIFY && type != GDK_LEAVE_NOTIFY) {
+    return false;
+  }
+  GtkNative *native = gtk_widget_get_native(GTK_WIDGET(surface_));
+  // popovers have their own surface and their event positions are local to it.
+  if (!native || gdk_event_get_surface(event) != gtk_native_get_surface(native)) {
+    return false;
+  }
+  if ((type == GDK_ENTER_NOTIFY || type == GDK_LEAVE_NOTIFY) && gdk_crossing_event_get_detail(event) == GDK_NOTIFY_INFERIOR) {
+    return false;
+  }
+  if ((type == GDK_BUTTON_PRESS || type == GDK_BUTTON_RELEASE) && gdk_button_event_get_button(event) != GDK_BUTTON_PRIMARY) {
+    return false;
+  }
+
+  // event positions are surface coordinates; the surface view sits at the window origin
+  double x = 0, y = 0;
+  gdk_event_get_position(event, &x, &y);
+  double offsetX = 0, offsetY = 0;
+  gtk_native_get_surface_transform(native, &offsetX, &offsetY);
+  graphene_point_t in = GRAPHENE_POINT_INIT(static_cast<float>(x - offsetX), static_cast<float>(y - offsetY));
+  graphene_point_t point;
+  if (!gtk_widget_compute_point(GTK_WIDGET(native), GTK_WIDGET(surface_), &in, &point)) {
+    return false;
+  }
+  x = point.x;
+  y = point.y;
+  modifiers_ = gdk_event_get_modifier_state(event);
+
+  if (type == GDK_MOTION_NOTIFY || type == GDK_ENTER_NOTIFY || type == GDK_LEAVE_NOTIFY) {
+    updateHover(x, y, type != GDK_LEAVE_NOTIFY);
+  }
+
+  if (type == GDK_BUTTON_PRESS) {
+    OneLinuxPointerTarget target{};
+    double localX = 0, localY = 0;
+    if (!hitTest(surface_, x, y, target, localX, localY)) {
+      return false;
+    }
+    touching_ = true;
+    touchTarget_ = target.tag;
+    sendPointer(target.tag, "down", x, y, 0);
+    send("start", x, y, true);
+  } else if (type == GDK_MOTION_NOTIFY) {
+    if (touching_) {
+      send("move", x, y, true);
+    }
+  } else if (type == GDK_BUTTON_RELEASE) {
+    if (!touching_) {
+      return false;
+    }
+    touching_ = false;
+    OneLinuxPointerTarget target{};
+    double localX = 0, localY = 0;
+    if (hitTest(surface_, x, y, target, localX, localY)) {
+      sendPointer(target.tag, "up", x, y, 0);
+    }
+    if (touchTarget_) {
+      send("end", x, y, false);
+      touchTarget_ = 0;
+    }
+  } else if (touching_ && type == GDK_GRAB_BROKEN) {
+    touching_ = false;
+    sendPointer(touchTarget_, "cancel", x, y);
+    send("cancel", x, y, false);
+    touchTarget_ = 0;
+  }
+  return false;
+}
+
+} // namespace facebook::react

package/linux/host/OneLinuxPointer.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <react/renderer/components/view/primitives.h>
+#include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/ReactPrimitives.h>
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "OneLinuxView.h"
+
+namespace facebook::react {
+
+// what hit testing needs to know about a mounted view
+struct OneLinuxPointerTarget {
+  Tag tag;
+  PointerEventsMode pointerEvents;
+  Cursor cursor;
+};
+
+// feeds mouse input through react native's touch and pointer event paths.
+// hit testing walks the mounted frames, transforms and scroll offsets.
+class OneLinuxPointerHandler {
+ public:
+  using Describe = std::function<bool(OneView *, OneLinuxPointerTarget &)>;
+  using EmitterFor = std::function<std::shared_ptr<const EventEmitter>(Tag)>;
+  using ViewFor = std::function<OneView *(Tag)>;
+
+  OneLinuxPointerHandler(OneView *surface, Describe describe, EmitterFor emitterFor, ViewFor viewFor);
+  ~OneLinuxPointerHandler();
+
+ private:
+  static gboolean onEvent(GtkEventControllerLegacy *controller, GdkEvent *event, gpointer data);
+  bool handle(GdkEvent *event);
+  OneView *hitChildren(OneView *parent, double x, double y, OneLinuxPointerTarget &target, double &localX, double &localY);
+  OneView *hitTest(OneView *view, double x, double y, OneLinuxPointerTarget &target, double &localX, double &localY);
+  bool localPoint(Tag tag, double x, double y, double &localX, double &localY);
+  void send(const char *phase, double x, double y, bool stillDown);
+  void updateHover(double x, double y, bool inside);
+  void sendPointer(Tag tag, const char *type, double x, double y, int button = -1);
+
+  OneView *surface_;
+  GtkEventController *controller_;
+  Describe describe_;
+  EmitterFor emitterFor_;
+  ViewFor viewFor_;
+
+  Tag hoverTarget_{0};
+  Cursor cursor_{Cursor::Auto};
+
+  bool touching_{false};
+  Tag touchTarget_{0};
+  GdkModifierType modifiers_{};
+};
+
+} // namespace facebook::react

package/linux/host/OneLinuxRuntime.cpp

@@ -0,0 +1,204 @@
+#include "OneLinuxRuntime.h"
+
+namespace facebook::react {
+
+OneLinuxMessageQueueThread::OneLinuxMessageQueueThread() : thread_([this] { run(); }) {}
+
+OneLinuxMessageQueueThread::~OneLinuxMessageQueueThread()
+{
+  quitSynchronous();
+}
+
+bool OneLinuxMessageQueueThread::isOnThread() const
+{
+  return std::this_thread::get_id() == thread_.get_id();
+}
+
+void OneLinuxMessageQueueThread::runOnQueue(std::function<void()> &&work)
+{
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (quit_) {
+      return;
+    }
+    queue_.push_back(std::move(work));
+  }
+  wake_.notify_one();
+}
+
+void OneLinuxMessageQueueThread::quitSynchronous()
+{
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (quit_) {
+      return;
+    }
+    quit_ = true;
+  }
+  wake_.notify_one();
+  if (!isOnThread()) {
+    thread_.join();
+  }
+}
+
+void OneLinuxMessageQueueThread::run()
+{
+  pthread_setname_np(pthread_self(), "one-javascript");
+  for (;;) {
+    std::function<void()> work;
+    {
+      std::unique_lock<std::mutex> lock(mutex_);
+      wake_.wait(lock, [this] { return quit_ || !queue_.empty(); });
+      if (queue_.empty()) {
+        return;
+      }
+      work = std::move(queue_.front());
+      queue_.pop_front();
+    }
+    work();
+  }
+}
+
+namespace {
+
+struct TimerData {
+  OneLinuxTimerRegistry *registry;
+  std::function<void()> fire;
+};
+
+} // namespace
+
+OneLinuxTimerRegistry::~OneLinuxTimerRegistry()
+{
+  disarmAll();
+}
+
+void OneLinuxTimerRegistry::arm(uint32_t timerID, double delayMS, bool repeats)
+{
+  GSource *source = g_timeout_source_new(static_cast<guint>(std::max(delayMS, 1.0)));
+  auto *fire = new std::function<void()>([this, timerID, repeats] { this->fire(timerID, repeats); });
+  g_source_set_callback(
+      source,
+      [](gpointer data) -> gboolean {
+        (*static_cast<std::function<void()> *>(data))();
+        return G_SOURCE_CONTINUE;
+      },
+      fire,
+      [](gpointer data) { delete static_cast<std::function<void()> *>(data); });
+
+  std::lock_guard<std::mutex> lock(mutex_);
+  auto existing = sources_.find(timerID);
+  if (existing != sources_.end()) {
+    g_source_destroy(existing->second);
+    g_source_unref(existing->second);
+  }
+  sources_[timerID] = source;
+  g_source_attach(source, nullptr);
+}
+
+void OneLinuxTimerRegistry::disarm(uint32_t timerID)
+{
+  std::lock_guard<std::mutex> lock(mutex_);
+  auto it = sources_.find(timerID);
+  if (it != sources_.end()) {
+    g_source_destroy(it->second);
+    g_source_unref(it->second);
+    sources_.erase(it);
+  }
+}
+
+void OneLinuxTimerRegistry::disarmAll()
+{
+  std::lock_guard<std::mutex> lock(mutex_);
+  for (auto &entry : sources_) {
+    g_source_destroy(entry.second);
+    g_source_unref(entry.second);
+  }
+  sources_.clear();
+}
+
+namespace {
+
+struct ObserverSource {
+  GSource base;
+  const OneLinuxRunLoopObserver *observer;
+};
+
+gboolean observerPrepare(GSource *source, gint *timeout)
+{
+  *timeout = -1;
+  static_cast<ObserverSource *>(static_cast<void *>(source))->observer->tick();
+  return FALSE;
+}
+
+gboolean observerCheck(GSource *)
+{
+  return FALSE;
+}
+
+gboolean observerDispatch(GSource *, GSourceFunc, gpointer)
+{
+  return G_SOURCE_CONTINUE;
+}
+
+GSourceFuncs observerFuncs = {observerPrepare, observerCheck, observerDispatch, nullptr, nullptr, nullptr};
+
+} // namespace
+
+OneLinuxRunLoopObserver::OneLinuxRunLoopObserver(Activity activities, WeakOwner owner)
+    : RunLoopObserver(activities, std::move(owner))
+{
+}
+
+OneLinuxRunLoopObserver::~OneLinuxRunLoopObserver() noexcept
+{
+  stopObserving();
+}
+
+bool OneLinuxRunLoopObserver::isOnRunLoopThread() const noexcept
+{
+  return g_main_context_is_owner(g_main_context_default());
+}
+
+void OneLinuxRunLoopObserver::tick() const noexcept
+{
+  if (auto strongOwner = owner_.lock()) {
+    activityDidChange(BeforeWaiting);
+  }
+}
+
+void OneLinuxRunLoopObserver::startObserving() const noexcept
+{
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (source_) {
+    return;
+  }
+  source_ = g_source_new(&observerFuncs, sizeof(ObserverSource));
+  reinterpret_cast<ObserverSource *>(source_)->observer = this;
+  g_source_attach(source_, nullptr);
+}
+
+void OneLinuxRunLoopObserver::stopObserving() const noexcept
+{
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (source_) {
+    g_source_destroy(source_);
+    g_source_unref(source_);
+    source_ = nullptr;
+  }
+}
+
+void OneLinuxDispatchMain(std::function<void()> work)
+{
+  g_idle_add_full(
+      G_PRIORITY_DEFAULT,
+      [](gpointer data) -> gboolean {
+        auto *work = static_cast<std::function<void()> *>(data);
+        (*work)();
+        return G_SOURCE_REMOVE;
+      },
+      new std::function<void()>(std::move(work)),
+      [](gpointer data) { delete static_cast<std::function<void()> *>(data); });
+}
+
+} // namespace facebook::react

package/linux/host/OneLinuxRuntime.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <glib.h>
+
+#include <condition_variable>
+#include <deque>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+#include <react/utils/RunLoopObserver.h>
+
+#include "OneHostRuntime.h"
+
+namespace facebook::react {
+
+// The JavaScript thread: one thread draining a work queue, with the serial
+// queue contract React's runtime expects.
+class OneLinuxMessageQueueThread : public OneMessageQueueThread {
+ public:
+  OneLinuxMessageQueueThread();
+  ~OneLinuxMessageQueueThread() override;
+
+  void runOnQueue(std::function<void()> &&work) override;
+  void quitSynchronous() override;
+
+  bool isOnThread() const override;
+
+ private:
+  void run();
+
+  std::mutex mutex_;
+  std::condition_variable wake_;
+  std::deque<std::function<void()>> queue_;
+  bool quit_{false};
+  std::thread thread_;
+};
+
+// Timers are GLib timeout sources on the main context; TimerManager hops to the
+// JS thread itself.
+class OneLinuxTimerRegistry : public OneTimerRegistry {
+ public:
+  ~OneLinuxTimerRegistry() override;
+
+ protected:
+  void arm(uint32_t timerID, double delayMS, bool repeats) override;
+  void disarm(uint32_t timerID) override;
+  void disarmAll() override;
+
+ private:
+  std::mutex mutex_;
+  std::map<uint32_t, GSource *> sources_;
+};
+
+// BeforeWaiting is the prepare step of a source on the main context, which GLib
+// runs on every iteration before the loop polls and sleeps.
+class OneLinuxRunLoopObserver : public RunLoopObserver {
+ public:
+  OneLinuxRunLoopObserver(Activity activities, WeakOwner owner);
+  ~OneLinuxRunLoopObserver() noexcept override;
+
+  bool isOnRunLoopThread() const noexcept override;
+
+  void tick() const noexcept;
+
+ protected:
+  void startObserving() const noexcept override;
+  void stopObserving() const noexcept override;
+
+ private:
+  mutable GSource *source_{nullptr};
+  mutable std::mutex mutex_;
+};
+
+// posts to the main loop; the work runs before the next frame is laid out
+void OneLinuxDispatchMain(std::function<void()> work);
+
+} // namespace facebook::react