Expose UIManager from Scheduler

React/Fabric/RCTScheduler.h

@@ -10,11 +10,13 @@
 
 #import <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #import <react/renderer/core/ComponentDescriptor.h>
+#import <react/renderer/core/EventListener.h>
 #import <react/renderer/core/LayoutConstraints.h>
 #import <react/renderer/core/LayoutContext.h>
 #import <react/renderer/mounting/MountingCoordinator.h>
 #import <react/renderer/scheduler/SchedulerToolbox.h>
 #import <react/renderer/scheduler/SurfaceHandler.h>
+#import <react/renderer/uimanager/UIManager.h>
 #import <react/utils/ContextContainer.h>
 
 NS_ASSUME_NONNULL_BEGIN
@@ -47,6 +49,7 @@ NS_ASSUME_NONNULL_BEGIN
 @interface RCTScheduler : NSObject
 
 @property (atomic, weak, nullable) id<RCTSchedulerDelegate> delegate;
+@property (readonly, nullable) facebook::react::UIManager const *uiManager;
 
 - (instancetype)initWithToolbox:(facebook::react::SchedulerToolbox)toolbox;
 
@@ -64,6 +67,10 @@ NS_ASSUME_NONNULL_BEGIN
 
 - (void)animationTick;
 
+- (void)addEventListener:(std::shared_ptr<facebook::react::EventListener> const &)listener;
+
+- (void)removeEventListener:(std::shared_ptr<facebook::react::EventListener> const &)listener;
+
 @end
 
 NS_ASSUME_NONNULL_END

React/Fabric/RCTScheduler.mm

@@ -193,4 +193,19 @@ - (void)onAllAnimationsComplete
   }
 }
 
+- (void)addEventListener:(std::shared_ptr<EventListener> const &)listener
+{
+  return _scheduler->addEventListener(listener);
+}
+
+- (void)removeEventListener:(std::shared_ptr<EventListener> const &)listener
+{
+  return _scheduler->removeEventListener(listener);
+}
+
+- (facebook::react::UIManager const *)uiManager
+{
+  return _scheduler->getUIManager().get();
+}
+
 @end

React/Fabric/RCTSurfacePresenter.h

@@ -19,6 +19,7 @@ NS_ASSUME_NONNULL_BEGIN
 @class RCTFabricSurface;
 @class RCTImageLoader;
 @class RCTMountingManager;
+@class RCTScheduler;
 
 /**
  * Coordinates presenting of React Native Surfaces and represents application
@@ -53,6 +54,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)unregisterSurface:(RCTFabricSurface *)surface;
 
 @property (readonly) RCTMountingManager *mountingManager;
+@property (readonly, nullable) RCTScheduler *scheduler;
 
 /*
  * Allow callers to initialize a new fabric surface without adding Fabric as a Buck dependency.

React/Fabric/RCTSurfacePresenter.mm

@@ -115,7 +115,7 @@ - (RCTMountingManager *)mountingManager
   return _mountingManager;
 }
 
-- (RCTScheduler *_Nullable)_scheduler
+- (RCTScheduler *_Nullable)scheduler
 {
   std::lock_guard<std::mutex> lock(_schedulerAccessMutex);
   return _scheduler;
@@ -151,15 +151,15 @@ - (void)setRuntimeExecutor:(RuntimeExecutor)runtimeExecutor
 - (void)registerSurface:(RCTFabricSurface *)surface
 {
   [_surfaceRegistry registerSurface:surface];
-  RCTScheduler *scheduler = [self _scheduler];
+  RCTScheduler *scheduler = [self scheduler];
   if (scheduler) {
     [scheduler registerSurface:surface.surfaceHandler];
   }
 }
 
 - (void)unregisterSurface:(RCTFabricSurface *)surface
 {
-  RCTScheduler *scheduler = [self _scheduler];
+  RCTScheduler *scheduler = [self scheduler];
   if (scheduler) {
     [scheduler unregisterSurface:surface.surfaceHandler];
   }
@@ -188,7 +188,7 @@ - (UIView *)findComponentViewWithTag_DO_NOT_USE_DEPRECATED:(NSInteger)tag
 
 - (BOOL)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag props:(NSDictionary *)props
 {
-  RCTScheduler *scheduler = [self _scheduler];
+  RCTScheduler *scheduler = [self scheduler];
   if (!scheduler) {
     return NO;
   }
@@ -212,7 +212,7 @@ - (BOOL)synchronouslyUpdateViewOnUIThread:(NSNumber *)reactTag props:(NSDictiona
 
 - (void)setupAnimationDriverWithSurfaceHandler:(facebook::react::SurfaceHandler const &)surfaceHandler
 {
-  [[self _scheduler] setupAnimationDriver:surfaceHandler];
+  [[self scheduler] setupAnimationDriver:surfaceHandler];
 }
 
 - (BOOL)suspend

ReactAndroid/src/main/java/com/facebook/react/fabric/jni/Binding.h

@@ -43,6 +43,8 @@ class Binding : public jni::HybridClass<Binding>,
 
   static void registerNatives();
 
+  std::shared_ptr<Scheduler> getScheduler();
+
  private:
   void setConstraints(
       jint surfaceId,
@@ -133,7 +135,6 @@ class Binding : public jni::HybridClass<Binding>,
   std::shared_ptr<FabricMountingManager> mountingManager_;
   std::shared_ptr<Scheduler> scheduler_;
 
-  std::shared_ptr<Scheduler> getScheduler();
   std::shared_ptr<FabricMountingManager> verifyMountingManager(
       std::string const &locationHint);
 

ReactAndroid/src/main/java/com/facebook/react/fabric/jni/JFabricUIManager.cpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "JFabricUIManager.h"
+
+namespace facebook::react {
+
+Binding *JFabricUIManager::getBinding() {
+  static const auto bindingField =
+      javaClassStatic()->getField<Binding::javaobject>("mBinding");
+
+  return getFieldValue(bindingField)->cthis();
+}
+} // namespace facebook::react

ReactAndroid/src/main/java/com/facebook/react/fabric/jni/JFabricUIManager.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Binding.h"
+
+using namespace facebook::jni;
+
+namespace facebook::react {
+
+class JFabricUIManager : public JavaClass<JFabricUIManager> {
+ public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/facebook/react/fabric/FabricUIManager;";
+
+  Binding *getBinding();
+};
+
+} // namespace facebook::react

ReactCommon/react/renderer/core/EventDispatcher.cpp

@@ -36,6 +36,10 @@ EventDispatcher::EventDispatcher(
 
 void EventDispatcher::dispatchEvent(RawEvent &&rawEvent, EventPriority priority)
     const {
+  // Allows the event listener to interrupt default event dispatch
+  if (eventListeners_.willDispatchEvent(rawEvent)) {
+    return;
+  }
   getEventQueue(priority).enqueueEvent(std::move(rawEvent));
 }
 
@@ -46,6 +50,10 @@ void EventDispatcher::dispatchStateUpdate(
 }
 
 void EventDispatcher::dispatchUniqueEvent(RawEvent &&rawEvent) const {
+  // Allows the event listener to interrupt default event dispatch
+  if (eventListeners_.willDispatchEvent(rawEvent)) {
+    return;
+  }
   asynchronousBatchedQueue_->enqueueUniqueEvent(std::move(rawEvent));
 }
 
@@ -62,5 +70,18 @@ const EventQueue &EventDispatcher::getEventQueue(EventPriority priority) const {
   }
 }
 
+void EventDispatcher::addListener(
+    const std::shared_ptr<EventListener const> &listener) const {
+  eventListeners_.addListener(listener);
+}
+
+/*
+ * Removes provided event listener to the event dispatcher.
+ */
+void EventDispatcher::removeListener(
+    const std::shared_ptr<EventListener const> &listener) const {
+  eventListeners_.removeListener(listener);
+}
+
 } // namespace react
 } // namespace facebook

ReactCommon/react/renderer/core/EventDispatcher.h

@@ -9,6 +9,7 @@
 
 #include <react/renderer/core/BatchedEventQueue.h>
 #include <react/renderer/core/EventBeat.h>
+#include <react/renderer/core/EventListener.h>
 #include <react/renderer/core/EventPriority.h>
 #include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/StateUpdate.h>
@@ -52,13 +53,27 @@ class EventDispatcher {
   void dispatchStateUpdate(StateUpdate &&stateUpdate, EventPriority priority)
       const;
 
+#pragma mark - Event listeners
+  /*
+   * Adds provided event listener to the event dispatcher.
+   */
+  void addListener(const std::shared_ptr<EventListener const> &listener) const;
+
+  /*
+   * Removes provided event listener to the event dispatcher.
+   */
+  void removeListener(
+      const std::shared_ptr<EventListener const> &listener) const;
+
  private:
   EventQueue const &getEventQueue(EventPriority priority) const;
 
   std::unique_ptr<UnbatchedEventQueue> synchronousUnbatchedQueue_;
   std::unique_ptr<BatchedEventQueue> synchronousBatchedQueue_;
   std::unique_ptr<UnbatchedEventQueue> asynchronousUnbatchedQueue_;
   std::unique_ptr<BatchedEventQueue> asynchronousBatchedQueue_;
+
+  mutable EventListenerContainer eventListeners_;
 };
 
 } // namespace react

ReactCommon/react/renderer/core/EventListener.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "EventListener.h"
+
+namespace facebook::react {
+
+bool EventListenerContainer::willDispatchEvent(const RawEvent &event) {
+  std::shared_lock<butter::shared_mutex> lock(mutex_);
+
+  bool handled = false;
+  for (auto const &listener : eventListeners_) {
+    handled = handled || listener->operator()(event);
+  }
+  return handled;
+}
+
+void EventListenerContainer::addListener(
+    const std::shared_ptr<EventListener const> &listener) {
+  std::unique_lock<butter::shared_mutex> lock(mutex_);
+
+  eventListeners_.push_back(listener);
+}
+
+void EventListenerContainer::removeListener(
+    const std::shared_ptr<EventListener const> &listener) {
+  std::unique_lock<butter::shared_mutex> lock(mutex_);
+
+  auto it = std::find(eventListeners_.begin(), eventListeners_.end(), listener);
+  if (it != eventListeners_.end()) {
+    eventListeners_.erase(it);
+  }
+}
+
+} // namespace facebook::react

ReactCommon/react/renderer/core/EventListener.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <string>
+
+#include <react/renderer/core/RawEvent.h>
+
+#include <butter/mutex.h>
+
+namespace facebook {
+namespace react {
+
+/**
+ * Listener for events dispatched to JS runtime.
+ * Return `true` to interrupt default dispatch to JS event emitter, `false` to
+ * pass through to default handlers.
+ */
+using EventListener = std::function<bool(const RawEvent &event)>;
+
+class EventListenerContainer {
+ public:
+  /*
+   * Invoke listeners in this container with the event.
+   * Returns true if event was handled by the listener, false to continue
+   * default dispatch.
+   */
+  bool willDispatchEvent(const RawEvent &event);
+
+  void addListener(const std::shared_ptr<EventListener const> &listener);
+  void removeListener(const std::shared_ptr<EventListener const> &listener);
+
+ private:
+  butter::shared_mutex mutex_;
+  std::vector<std::shared_ptr<EventListener const>> eventListeners_;
+};
+
+} // namespace react
+} // namespace facebook

ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -368,5 +368,23 @@ ContextContainer::Shared Scheduler::getContextContainer() const {
   return contextContainer_;
 }
 
+std::shared_ptr<UIManager> Scheduler::getUIManager() const {
+  return uiManager_;
+}
+
+void Scheduler::addEventListener(
+    const std::shared_ptr<EventListener const> &listener) {
+  if (eventDispatcher_->has_value()) {
+    eventDispatcher_->value().addListener(listener);
+  }
+}
+
+void Scheduler::removeEventListener(
+    const std::shared_ptr<EventListener const> &listener) {
+  if (eventDispatcher_->has_value()) {
+    eventDispatcher_->value().removeListener(listener);
+  }
+}
+
 } // namespace react
 } // namespace facebook

ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -16,6 +16,7 @@
 #include <react/renderer/components/root/RootComponentDescriptor.h>
 #include <react/renderer/core/ComponentDescriptor.h>
 #include <react/renderer/core/EventEmitter.h>
+#include <react/renderer/core/EventListener.h>
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/scheduler/InspectorData.h>
@@ -107,6 +108,14 @@ class Scheduler final : public UIManagerDelegate {
 #pragma mark - ContextContainer
   ContextContainer::Shared getContextContainer() const;
 
+#pragma mark - UIManager
+  std::shared_ptr<UIManager> getUIManager() const;
+
+#pragma mark - Event listeners
+  void addEventListener(const std::shared_ptr<EventListener const> &listener);
+  void removeEventListener(
+      const std::shared_ptr<EventListener const> &listener);
+
  private:
   friend class SurfaceHandler;