react-native 0.0.0-263478b91 → 0.0.0-268efb102

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIManagerHelper.java

@@ -20,7 +20,7 @@ import com.facebook.react.bridge.CatalystInstance;
 import com.facebook.react.bridge.JSIModuleType;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.EventDispatcher;
@@ -55,7 +55,7 @@ public class UIManagerHelper {
     if (context.isBridgeless()) {
       @Nullable UIManager uiManager = (UIManager) context.getJSIModule(JSIModuleType.UIManager);
       if (uiManager == null) {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG,
             new ReactNoCrashSoftException(
                 "Cannot get UIManager because the instance hasn't been initialized yet."));
@@ -65,7 +65,7 @@ public class UIManagerHelper {
     }
 
     if (!context.hasCatalystInstance()) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
               "Cannot get UIManager because the context doesn't contain a CatalystInstance."));
@@ -74,7 +74,7 @@ public class UIManagerHelper {
     // TODO T60461551: add tests to verify emission of events when the ReactContext is being turn
     // down.
     if (!context.hasActiveReactInstance()) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
               "Cannot get UIManager because the context doesn't contain an active CatalystInstance."));
@@ -89,7 +89,7 @@ public class UIManagerHelper {
           : catalystInstance.getNativeModule(UIManagerModule.class);
     } catch (IllegalArgumentException ex) {
       // TODO T67518514 Clean this up once we migrate everything over to bridgeless mode
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
               "Cannot get UIManager for UIManagerType: " + uiManagerType));
@@ -105,7 +105,7 @@ public class UIManagerHelper {
   public static EventDispatcher getEventDispatcherForReactTag(ReactContext context, int reactTag) {
     EventDispatcher eventDispatcher = getEventDispatcher(context, getUIManagerType(reactTag));
     if (eventDispatcher == null) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG, new IllegalStateException("Cannot get EventDispatcher for reactTag " + reactTag));
     }
     return eventDispatcher;
@@ -127,7 +127,7 @@ public class UIManagerHelper {
     }
     UIManager uiManager = getUIManager(context, uiManagerType, false);
     if (uiManager == null) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
               "Unable to find UIManager for UIManagerType " + uiManagerType));
@@ -135,7 +135,7 @@ public class UIManagerHelper {
     }
     EventDispatcher eventDispatcher = (EventDispatcher) uiManager.getEventDispatcher();
     if (eventDispatcher == null) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new IllegalStateException(
               "Cannot get EventDispatcher for UIManagerType " + uiManagerType));
@@ -180,7 +180,7 @@ public class UIManagerHelper {
 
     // All Fabric-managed Views (should) have a ThemedReactContext attached.
     if (surfaceId == -1) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new IllegalStateException(
               "Fabric View [" + reactTag + "] does not have SurfaceId associated with it"));

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIManagerModule.java

@@ -114,6 +114,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   private volatile int mViewManagerConstantsCacheSize;
 
   private int mBatchId = 0;
+  private int mNumRootViews = 0;
 
   @SuppressWarnings("deprecated")
   public UIManagerModule(
@@ -442,6 +443,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
             -1);
 
     mUIImplementation.registerRootView(rootView, tag, themedRootContext);
+    mNumRootViews++;
     Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     return tag;
   }
@@ -465,6 +467,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
   @ReactMethod
   public void removeRootView(int rootViewTag) {
     mUIImplementation.removeRootView(rootViewTag);
+    mNumRootViews--;
   }
 
   public void updateNodeSize(int nodeViewTag, int newWidth, int newHeight) {
@@ -805,7 +808,12 @@ public class UIManagerModule extends ReactContextBaseJavaModule
       listener.willDispatchViewUpdates(this);
     }
     try {
-      mUIImplementation.dispatchViewUpdates(batchId);
+      // If there are no RootViews registered, there will be no View updates to dispatch.
+      // This is a hack to prevent this from being called when Fabric is used everywhere.
+      // This should no longer be necessary in Bridgeless Mode.
+      if (mNumRootViews > 0) {
+        mUIImplementation.dispatchViewUpdates(batchId);
+      }
     } finally {
       Systrace.endSection(Systrace.TRACE_TAG_REACT_JAVA_BRIDGE);
     }
@@ -947,6 +955,7 @@ public class UIManagerModule extends ReactContextBaseJavaModule
     public void onLowMemory() {}
   }
 
+  @Override
   public View resolveView(int tag) {
     UiThreadUtil.assertOnUiThread();
     return mUIImplementation

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/UIViewOperationQueue.java

@@ -18,7 +18,7 @@ import com.facebook.react.bridge.GuardedRunnable;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.RetryableMountingLayerException;
@@ -313,7 +313,7 @@ public class UIViewOperationQueue {
       try {
         mNativeViewHierarchyManager.dispatchCommand(mTag, mCommand, mArgs);
       } catch (Throwable e) {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG, new RuntimeException("Error dispatching View Command", e));
       }
     }
@@ -354,7 +354,7 @@ public class UIViewOperationQueue {
       try {
         mNativeViewHierarchyManager.dispatchCommand(mTag, mCommand, mArgs);
       } catch (Throwable e) {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG, new RuntimeException("Error dispatching View Command", e));
       }
     }
@@ -892,11 +892,12 @@ public class UIViewOperationQueue {
                         mViewCommandOperations.add(op);
                       } else {
                         // Retryable exceptions should be logged, but never crash in debug.
-                        ReactSoftException.logSoftException(TAG, new ReactNoCrashSoftException(e));
+                        ReactSoftExceptionLogger.logSoftException(
+                            TAG, new ReactNoCrashSoftException(e));
                       }
                     } catch (Throwable e) {
                       // Non-retryable exceptions should be logged in prod, and crash in Debug.
-                      ReactSoftException.logSoftException(TAG, e);
+                      ReactSoftExceptionLogger.logSoftException(TAG, e);
                     }
                   }
                 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/ViewManagersPropertyCache.java

@@ -325,6 +325,21 @@ import java.util.Map;
     }
   }
 
+  private static class BoxedColorPropSetter extends PropSetter {
+
+    public BoxedColorPropSetter(ReactProp prop, Method setter) {
+      super(prop, "mixed", setter);
+    }
+
+    @Override
+    protected @Nullable Object getValueOrDefault(Object value, Context context) {
+      if (value != null) {
+        return ColorPropConverter.getColor(value, context);
+      }
+      return null;
+    }
+  }
+
   /*package*/ static Map<String, String> getNativePropsForView(
       Class<? extends ViewManager> viewManagerTopClass,
       Class<? extends ReactShadowNode> shadowNodeTopClass) {
@@ -418,7 +433,7 @@ import java.util.Map;
       return new BoxedBooleanPropSetter(annotation, method);
     } else if (propTypeClass == Integer.class) {
       if ("Color".equals(annotation.customType())) {
-        return new ColorPropSetter(annotation, method);
+        return new BoxedColorPropSetter(annotation, method);
       }
       return new BoxedIntPropSetter(annotation, method);
     } else if (propTypeClass == ReadableArray.class) {

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/Event.java

@@ -11,6 +11,7 @@ import androidx.annotation.Nullable;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.SystemClock;
 import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.common.UIManagerType;
 
 /**
  * A UI event that can be dispatched to JS.
@@ -33,20 +34,12 @@ public abstract class Event<T extends Event> {
   private static int sUniqueID = 0;
 
   private boolean mInitialized;
+  private @UIManagerType int mUIManagerType;
   private int mSurfaceId;
   private int mViewTag;
   private long mTimestampMs;
   private int mUniqueID = sUniqueID++;
 
-  // Android native Event times use 'uptimeMillis', and historically we've used `uptimeMillis`
-  // throughout this Event class as the coalescing key for events, and for other purposes.
-  // To get an accurate(ish) absolute UNIX time for the event, we store the initial clock time here.
-  // uptimeMillis can then be added to this to get an accurate UNIX time.
-  // However, we still default to uptimeMillis: you must explicitly request UNIX time if you want
-  // that; see `getUnixTimestampMs`.
-  public static final long sInitialClockTimeUnixOffset =
-      SystemClock.currentTimeMillis() - SystemClock.uptimeMillis();
-
   protected Event() {}
 
   @Deprecated
@@ -63,14 +56,33 @@ public abstract class Event<T extends Event> {
     init(-1, viewTag);
   }
 
-  /** This method needs to be called before event is sent to event dispatcher. */
   protected void init(int surfaceId, int viewTag) {
+    init(surfaceId, viewTag, SystemClock.uptimeMillis());
+  }
+
+  /**
+   * This method needs to be called before event is sent to event dispatcher. Event timestamps can
+   * optionally be dated/backdated to a custom time: for example, touch events should be dated with
+   * the system event time.
+   */
+  protected void init(int surfaceId, int viewTag, long timestampMs) {
     mSurfaceId = surfaceId;
     mViewTag = viewTag;
-    mInitialized = true;
 
-    // This is a *relative* time. See `getUnixTimestampMs`.
-    mTimestampMs = SystemClock.uptimeMillis();
+    // We infer UIManagerType. Even though it's not passed in explicitly, we have a
+    // contract that Fabric events *always* have a SurfaceId passed in, and non-Fabric events
+    // NEVER have a SurfaceId passed in (the default/placeholder of -1 is passed in instead).
+    // Why does this matter?
+    // Events can be sent to Views that are part of the View hierarchy *but not directly managed
+    // by React Native*. For example, embedded custom hierachies, Litho hierachies, etc.
+    // In those cases it's important to konw that the Event should be sent to the Fabric or
+    // non-Fabric UIManager, and we cannot use the ViewTag for inference since it's not controlled
+    // by RN and is essentially a random number.
+    // At some point it would be great to pass the SurfaceContext here instead.
+    mUIManagerType = (surfaceId == -1 ? UIManagerType.DEFAULT : UIManagerType.FABRIC);
+
+    mTimestampMs = timestampMs;
+    mInitialized = true;
   }
 
   /** @return the view id for the view that generated this event */
@@ -91,11 +103,6 @@ public abstract class Event<T extends Event> {
     return mTimestampMs;
   }
 
-  /** @return the time at which the event happened as a UNIX timestamp, in milliseconds. */
-  public final long getUnixTimestampMs() {
-    return sInitialClockTimeUnixOffset + mTimestampMs;
-  }
-
   /** @return false if this Event can *never* be coalesced */
   public boolean canCoalesce() {
     return true;
@@ -142,6 +149,10 @@ public abstract class Event<T extends Event> {
     onDispose();
   }
 
+  public final @UIManagerType int getUIManagerType() {
+    return mUIManagerType;
+  }
+
   /** @return the name of this event as registered in JS */
   public abstract String getEventName();
 
@@ -155,7 +166,7 @@ public abstract class Event<T extends Event> {
     WritableMap eventData = getEventData();
     if (eventData == null) {
       throw new IllegalViewOperationException(
-          "Event: you must return a valid, non-null value from `getEventData`, or override `dispatch` and `disatchModern`. Event: "
+          "Event: you must return a valid, non-null value from `getEventData`, or override `dispatch` and `dispatchModern`. Event: "
               + getEventName());
     }
     rctEventEmitter.receiveEvent(getViewTag(), getEventName(), eventData);
@@ -188,4 +199,27 @@ public abstract class Event<T extends Event> {
     }
     dispatch(rctEventEmitter);
   }
+
+  /**
+   * Dispatch this event to JS using a V2 version of dispatchModern. See all comments from
+   * `dispatchModern` - all still apply. This method additionally allows C++ to coalesce events
+   * (Fabric only). This will ONLY be called in an experimental path, and in Fabric only.
+   */
+  @Deprecated
+  public void dispatchModernV2(RCTModernEventEmitter rctEventEmitter) {
+    if (getSurfaceId() != -1) {
+      WritableMap eventData = getEventData();
+      if (eventData != null) {
+        rctEventEmitter.receiveEvent(
+            getSurfaceId(),
+            getViewTag(),
+            getEventName(),
+            canCoalesce(),
+            getCoalescingKey(),
+            eventData);
+        return;
+      }
+    }
+    dispatch(rctEventEmitter);
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/LockFreeEventDispatcherImpl.java

@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.uimanager.events;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.common.build.ReactBuildConfig;
+import com.facebook.react.modules.core.ChoreographerCompat;
+import com.facebook.react.modules.core.ReactChoreographer;
+import com.facebook.react.uimanager.common.UIManagerType;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * Class responsible for dispatching UI events to JS. The main purpose of this class is to act as an
+ * intermediary between UI code generating events and JS, making sure we don't send more events than
+ * JS can process.
+ *
+ * <p>To use it, create a subclass of {@link Event} and call {@link #dispatchEvent(Event)} whenever
+ * there's a UI event to dispatch.
+ *
+ * <p>This class works by installing a Choreographer frame callback on the main thread. This
+ * callback then enqueues a runnable on the JS thread (if one is not already pending) that is
+ * responsible for actually dispatch events to JS. This implementation depends on the properties
+ * that 1) FrameCallbacks run after UI events have been processed in Choreographer.java 2) when we
+ * enqueue a runnable on the JS queue thread, it won't be called until after any previously enqueued
+ * JS jobs have finished processing
+ *
+ * <p>If JS is taking a long time processing events, then the UI events generated on the UI thread
+ * can be coalesced into fewer events so that when the runnable runs, we don't overload JS with a
+ * ton of events and make it get even farther behind.
+ *
+ * <p>Ideally, we don't need this and JS is fast enough to process all the events each frame, but
+ * bad things happen, including load on CPUs from the system, and we should handle this case well.
+ *
+ * <p>== Event Cookies ==
+ *
+ * <p>An event cookie is made up of the event type id, view tag, and a custom coalescing key. Only
+ * Events that have the same cookie can be coalesced.
+ *
+ * <p>Event Cookie Composition: VIEW_TAG_MASK = 0x00000000ffffffff EVENT_TYPE_ID_MASK =
+ * 0x0000ffff00000000 COALESCING_KEY_MASK = 0xffff000000000000
+ *
+ * <p>This is a copy of EventDispatcherImpl, meant only to remove locking and synchronization.
+ */
+public class LockFreeEventDispatcherImpl implements EventDispatcher, LifecycleEventListener {
+
+  private final boolean DEBUG_MODE = ReactBuildConfig.DEBUG;
+  private final String TAG = LockFreeEventDispatcherImpl.class.getSimpleName();
+
+  private final ReactApplicationContext mReactContext;
+  private final CopyOnWriteArrayList<EventDispatcherListener> mListeners =
+      new CopyOnWriteArrayList<>();
+  private final CopyOnWriteArrayList<BatchEventDispatchedListener> mPostEventDispatchListeners =
+      new CopyOnWriteArrayList<>();
+  private final LockFreeEventDispatcherImpl.ScheduleDispatchFrameCallback mCurrentFrameCallback =
+      new LockFreeEventDispatcherImpl.ScheduleDispatchFrameCallback();
+
+  private volatile ReactEventEmitter mReactEventEmitter;
+
+  public LockFreeEventDispatcherImpl(ReactApplicationContext reactContext) {
+    mReactContext = reactContext;
+    mReactContext.addLifecycleEventListener(this);
+    mReactEventEmitter = new ReactEventEmitter(mReactContext);
+  }
+
+  /** Sends the given Event to C++, where it will be flushed to JS ASAP. */
+  public void dispatchEvent(Event event) {
+    Assertions.assertCondition(event.isInitialized(), "Dispatched event hasn't been initialized");
+    Assertions.assertNotNull(mReactEventEmitter);
+
+    if (DEBUG_MODE) {
+      FLog.v(TAG, "dispatchEvent: " + event.toString());
+    }
+
+    for (EventDispatcherListener listener : mListeners) {
+      listener.onEventDispatch(event);
+    }
+
+    event.dispatchModernV2(mReactEventEmitter);
+    event.dispose();
+  }
+
+  public void dispatchAllEvents() {
+    maybePostFrameCallbackFromNonUI();
+  }
+
+  private void maybePostFrameCallbackFromNonUI() {
+    if (mReactEventEmitter != null) {
+      // If the host activity is paused, the frame callback may not be currently
+      // posted. Ensure that it is so that this event gets delivered promptly.
+      mCurrentFrameCallback.maybePostFromNonUI();
+    } else {
+      // No JS application has started yet, or resumed. This can happen when a ReactRootView is
+      // added to view hierarchy, but ReactContext creation has not completed yet. In this case, any
+      // touch event dispatch will hit this codepath, and we simply queue them so that they
+      // are dispatched once ReactContext creation completes and JS app is running.
+    }
+  }
+
+  /** Add a listener to this EventDispatcher. */
+  public void addListener(EventDispatcherListener listener) {
+    mListeners.add(listener);
+  }
+
+  /** Remove a listener from this EventDispatcher. */
+  public void removeListener(EventDispatcherListener listener) {
+    mListeners.remove(listener);
+  }
+
+  public void addBatchEventDispatchedListener(BatchEventDispatchedListener listener) {
+    mPostEventDispatchListeners.add(listener);
+  }
+
+  public void removeBatchEventDispatchedListener(BatchEventDispatchedListener listener) {
+    mPostEventDispatchListeners.remove(listener);
+  }
+
+  @Override
+  public void onHostResume() {
+    maybePostFrameCallbackFromNonUI();
+  }
+
+  @Override
+  public void onHostPause() {
+    stopFrameCallback();
+  }
+
+  @Override
+  public void onHostDestroy() {
+    stopFrameCallback();
+  }
+
+  public void onCatalystInstanceDestroyed() {
+    UiThreadUtil.runOnUiThread(
+        new Runnable() {
+          @Override
+          public void run() {
+            stopFrameCallback();
+          }
+        });
+  }
+
+  private void stopFrameCallback() {
+    UiThreadUtil.assertOnUiThread();
+    mCurrentFrameCallback.stop();
+  }
+
+  public void registerEventEmitter(@UIManagerType int uiManagerType, RCTEventEmitter eventEmitter) {
+    mReactEventEmitter.register(uiManagerType, eventEmitter);
+  }
+
+  public void registerEventEmitter(
+      @UIManagerType int uiManagerType, RCTModernEventEmitter eventEmitter) {
+    mReactEventEmitter.register(uiManagerType, eventEmitter);
+  }
+
+  public void unregisterEventEmitter(@UIManagerType int uiManagerType) {
+    mReactEventEmitter.unregister(uiManagerType);
+  }
+
+  private class ScheduleDispatchFrameCallback extends ChoreographerCompat.FrameCallback {
+    private volatile boolean mIsPosted = false;
+    private boolean mShouldStop = false;
+
+    @Override
+    public void doFrame(long frameTimeNanos) {
+      UiThreadUtil.assertOnUiThread();
+
+      if (mShouldStop) {
+        mIsPosted = false;
+      } else {
+        post();
+      }
+
+      driveEventBeats();
+    }
+
+    public void stop() {
+      mShouldStop = true;
+    }
+
+    public void maybePost() {
+      if (!mIsPosted) {
+        mIsPosted = true;
+        post();
+      }
+    }
+
+    private void post() {
+      ReactChoreographer.getInstance()
+          .postFrameCallback(ReactChoreographer.CallbackType.TIMERS_EVENTS, mCurrentFrameCallback);
+    }
+
+    public void maybePostFromNonUI() {
+      if (mIsPosted) {
+        return;
+      }
+
+      // We should only hit this slow path when we receive events while the host activity is paused.
+      if (mReactContext.isOnUiQueueThread()) {
+        maybePost();
+      } else {
+        mReactContext.runOnUiQueueThread(
+            new Runnable() {
+              @Override
+              public void run() {
+                maybePost();
+              }
+            });
+      }
+    }
+  }
+
+  /**
+   * Is this a misnomer? It's called "driveEventBeats" but then is just calls
+   * `onBatchEventDispatched` listeners? Practically, all that `onBatchEventDispatched` is used for
+   * in Fabric is to drive AsyncEventBeats.
+   *
+   * <p>If this class ships for Fabric, we should remove `driveEventBeats` from here entirely,
+   * because it no longer needs to be connected to this event dispatcher. We should/probably can
+   * also delete `onRequestEventBeat` entirely.
+   */
+  private void driveEventBeats() {
+    for (BatchEventDispatchedListener listener : mPostEventDispatchListeners) {
+      listener.onBatchEventDispatched();
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/RCTModernEventEmitter.java

@@ -21,4 +21,12 @@ import com.facebook.react.bridge.WritableMap;
  */
 public interface RCTModernEventEmitter extends RCTEventEmitter {
   void receiveEvent(int surfaceId, int targetTag, String eventName, @Nullable WritableMap event);
+
+  void receiveEvent(
+      int surfaceId,
+      int targetTag,
+      String eventName,
+      boolean canCoalesceEvent,
+      int customCoalesceKey,
+      @Nullable WritableMap event);
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/events/ReactEventEmitter.java

@@ -13,7 +13,7 @@ import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.common.UIManagerType;
@@ -59,6 +59,14 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
     receiveEvent(-1, targetReactTag, eventName, event);
   }
 
+  @Override
+  public void receiveEvent(
+      int surfaceId, int targetTag, String eventName, @Nullable WritableMap event) {
+    // The two additional params here, `canCoalesceEvent` and `customCoalesceKey`, have no
+    // meaning outside of Fabric.
+    receiveEvent(surfaceId, targetTag, eventName, false, 0, event);
+  }
+
   @Override
   public void receiveTouches(
       String eventName, WritableArray touches, WritableArray changedIndices) {
@@ -71,7 +79,7 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
     } else if (uiManagerType == UIManagerType.DEFAULT && getEventEmitter(reactTag) != null) {
       mRCTEventEmitter.receiveTouches(eventName, touches, changedIndices);
     } else {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
               "Cannot find EventEmitter for receivedTouches: ReactTag["
@@ -92,7 +100,7 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
       if (mReactContext.hasActiveReactInstance()) {
         mRCTEventEmitter = mReactContext.getJSModule(RCTEventEmitter.class);
       } else {
-        ReactSoftException.logSoftException(
+        ReactSoftExceptionLogger.logSoftException(
             TAG,
             new ReactNoCrashSoftException(
                 "Cannot get RCTEventEmitter from Context for reactTag: "
@@ -107,14 +115,20 @@ public class ReactEventEmitter implements RCTModernEventEmitter {
 
   @Override
   public void receiveEvent(
-      int surfaceId, int targetReactTag, String eventName, @Nullable WritableMap event) {
+      int surfaceId,
+      int targetReactTag,
+      String eventName,
+      boolean canCoalesceEvent,
+      int customCoalesceKey,
+      @Nullable WritableMap event) {
     @UIManagerType int uiManagerType = ViewUtil.getUIManagerType(targetReactTag);
     if (uiManagerType == UIManagerType.FABRIC && mFabricEventEmitter != null) {
-      mFabricEventEmitter.receiveEvent(surfaceId, targetReactTag, eventName, event);
+      mFabricEventEmitter.receiveEvent(
+          surfaceId, targetReactTag, eventName, canCoalesceEvent, customCoalesceKey, event);
     } else if (uiManagerType == UIManagerType.DEFAULT && getEventEmitter(targetReactTag) != null) {
       mRCTEventEmitter.receiveEvent(targetReactTag, eventName, event);
     } else {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
               "Cannot find EventEmitter for receiveEvent: SurfaceId["