react-native 0.0.0-17be3a003 → 0.0.0-18697adec

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["

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

@@ -11,6 +11,7 @@ import android.view.MotionEvent;
 import androidx.annotation.Nullable;
 import androidx.core.util.Pools;
 import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.SoftAssertions;
 
 /**
@@ -22,6 +23,7 @@ import com.facebook.react.bridge.SoftAssertions;
  * these coalescing keys are determined.
  */
 public class TouchEvent extends Event<TouchEvent> {
+  private static final String TAG = TouchEvent.class.getSimpleName();
 
   private static final int TOUCH_EVENTS_POOL_SIZE = 3;
 
@@ -43,7 +45,7 @@ public class TouchEvent extends Event<TouchEvent> {
         -1,
         viewTag,
         touchEventType,
-        motionEventToCopy,
+        Assertions.assertNotNull(motionEventToCopy),
         gestureStartTime,
         viewX,
         viewY,
@@ -67,7 +69,7 @@ public class TouchEvent extends Event<TouchEvent> {
         surfaceId,
         viewTag,
         touchEventType,
-        motionEventToCopy,
+        Assertions.assertNotNull(motionEventToCopy),
         gestureStartTime,
         viewX,
         viewY,
@@ -94,7 +96,7 @@ public class TouchEvent extends Event<TouchEvent> {
       float viewX,
       float viewY,
       TouchEventCoalescingKeyHelper touchEventCoalescingKeyHelper) {
-    super.init(surfaceId, viewTag);
+    super.init(surfaceId, viewTag, motionEventToCopy.getEventTime());
 
     SoftAssertions.assertCondition(
         gestureStartTime != UNSET, "Gesture start time must be initialized");
@@ -129,9 +131,25 @@ public class TouchEvent extends Event<TouchEvent> {
 
   @Override
   public void onDispose() {
-    Assertions.assertNotNull(mMotionEvent).recycle();
+    MotionEvent motionEvent = mMotionEvent;
     mMotionEvent = null;
-    EVENTS_POOL.release(this);
+    if (motionEvent != null) {
+      motionEvent.recycle();
+    }
+
+    // Either `this` is in the event pool, or motionEvent
+    // is null. It is in theory not possible for a TouchEvent to
+    // be in the EVENTS_POOL but for motionEvent to be null. However,
+    // out of an abundance of caution and to avoid memory leaks or
+    // other crashes at all costs, we attempt to release here and log
+    // a soft exception here if release throws an IllegalStateException
+    // due to `this` being over-released. This may indicate that there is
+    // a logic error in our events system or pooling mechanism.
+    try {
+      EVENTS_POOL.release(this);
+    } catch (IllegalStateException e) {
+      ReactSoftExceptionLogger.logSoftException(TAG, e);
+    }
   }
 
   @Override
@@ -163,6 +181,13 @@ public class TouchEvent extends Event<TouchEvent> {
 
   @Override
   public void dispatch(RCTEventEmitter rctEventEmitter) {
+    if (!hasMotionEvent()) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Cannot dispatch a TouchEvent that has no MotionEvent; the TouchEvent has been recycled"));
+      return;
+    }
     TouchesHelper.sendTouchEvent(
         rctEventEmitter,
         Assertions.assertNotNull(mTouchEventType),
@@ -181,6 +206,10 @@ public class TouchEvent extends Event<TouchEvent> {
     return mMotionEvent;
   }
 
+  private boolean hasMotionEvent() {
+    return mMotionEvent != null;
+  }
+
   public float getViewX() {
     return mViewX;
   }

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

@@ -64,7 +64,7 @@ public class TouchesHelper {
       touch.putDouble(LOCATION_Y_KEY, PixelUtil.toDIPFromPixel(locationY));
       touch.putInt(TARGET_SURFACE_KEY, surfaceId);
       touch.putInt(TARGET_KEY, reactTarget);
-      touch.putDouble(TIMESTAMP_KEY, event.getUnixTimestampMs());
+      touch.putDouble(TIMESTAMP_KEY, event.getTimestampMs());
       touch.putDouble(POINTER_IDENTIFIER_KEY, motionEvent.getPointerId(index));
       touches.pushMap(touch);
     }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/interfaces/ViewProps.java

@@ -9,6 +9,7 @@ package com.facebook.react.uimanager;
 
 import android.graphics.Color;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
 import java.util.Arrays;
 import java.util.HashSet;
 
@@ -258,8 +259,14 @@ public class ViewProps {
         // Ignore if explicitly set to default opacity.
         return map.isNull(OPACITY) || map.getDouble(OPACITY) == 1d;
       case BORDER_RADIUS: // Without a background color or border width set, a border won't show.
-        if (map.hasKey(BACKGROUND_COLOR) && map.getInt(BACKGROUND_COLOR) != Color.TRANSPARENT) {
-          return false;
+        if (map.hasKey(BACKGROUND_COLOR)) {
+          ReadableType valueType = map.getType(BACKGROUND_COLOR);
+          if (valueType == ReadableType.Number
+              && map.getInt(BACKGROUND_COLOR) != Color.TRANSPARENT) {
+            return false;
+          } else if (valueType != ReadableType.Null) {
+            return false;
+          }
         }
         if (map.hasKey(BORDER_WIDTH)
             && !map.isNull(BORDER_WIDTH)

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/jni/BUCK

@@ -19,7 +19,7 @@ rn_xplat_cxx_library(
     ],
     fbandroid_allow_jni_merging = True,
     labels = ["supermodule:xplat/default/public.react_native.infra"],
-    platforms = (ANDROID),
+    platforms = ANDROID,
     preprocessor_flags = [
         "-DLOG_TAG=\"ReactNative\"",
         "-DWITH_FBSYSTRACE=1",

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/jni/ComponentNameResolverManager.cpp

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <memory>
 #include <string>
 
 #include <fbjni/fbjni.h>
@@ -18,6 +17,8 @@
 namespace facebook {
 namespace react {
 
+using namespace facebook::jni;
+
 ComponentNameResolverManager::ComponentNameResolverManager(
     jni::alias_ref<ComponentNameResolverManager::javaobject> jThis,
     RuntimeExecutor runtimeExecutor,

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/jni/ComponentNameResolverManager.h

@@ -10,20 +10,14 @@
 #include <ReactCommon/CallInvokerHolder.h>
 #include <ReactCommon/RuntimeExecutor.h>
 #include <fbjni/fbjni.h>
-#include <jsi/jsi.h>
 #include <react/jni/JRuntimeExecutor.h>
-#include <memory>
 #include <set>
-#include <unordered_map>
-
-using namespace facebook::jni;
-using namespace facebook::jsi;
 
 namespace facebook {
 namespace react {
 
 class ComponentNameResolverManager
-    : public jni::HybridClass<ComponentNameResolverManager> {
+    : public facebook::jni::HybridClass<ComponentNameResolverManager> {
  public:
   static auto constexpr kJavaDescriptor =
       "Lcom/facebook/react/uimanager/ComponentNameResolverManager;";
@@ -31,28 +25,29 @@ class ComponentNameResolverManager
   constexpr static auto ComponentNameResolverJavaDescriptor =
       "com/facebook/react/uimanager/ComponentNameResolver";
 
-  static jni::local_ref<jhybriddata> initHybrid(
-      jni::alias_ref<jhybridobject> jThis,
-      jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutor,
-      jni::alias_ref<jobject> componentNameResolver);
+  static facebook::jni::local_ref<jhybriddata> initHybrid(
+      facebook::jni::alias_ref<jhybridobject> jThis,
+      facebook::jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutor,
+      facebook::jni::alias_ref<jobject> componentNameResolver);
 
   static void registerNatives();
 
  private:
   friend HybridBase;
-  jni::global_ref<ComponentNameResolverManager::javaobject> javaPart_;
+  facebook::jni::global_ref<ComponentNameResolverManager::javaobject> javaPart_;
   RuntimeExecutor runtimeExecutor_;
 
-  jni::global_ref<jobject> componentNameResolver_;
+  facebook::jni::global_ref<jobject> componentNameResolver_;
 
   std::set<std::string> componentNames_;
 
   void installJSIBindings();
 
   explicit ComponentNameResolverManager(
-      jni::alias_ref<ComponentNameResolverManager::jhybridobject> jThis,
+      facebook::jni::alias_ref<ComponentNameResolverManager::jhybridobject>
+          jThis,
       RuntimeExecutor runtimeExecutor,
-      jni::alias_ref<jobject> componentNameResolver);
+      facebook::jni::alias_ref<jobject> componentNameResolver);
 };
 
 } // namespace react

package/ReactAndroid/src/main/java/com/facebook/react/views/drawer/BUCK

@@ -26,6 +26,6 @@ rn_android_library(
         react_native_target("java/com/facebook/react/uimanager:uimanager"),
         react_native_target("java/com/facebook/react/uimanager/annotations:annotations"),
         react_native_target("java/com/facebook/react/views/scroll:scroll"),
-        react_native_root_target("Libraries:generated_components_java-FBReactNativeComponentSpec"),
+        react_native_root_target(":generated_components_java-FBReactNativeComponentSpec"),
     ],
 )

package/ReactAndroid/src/main/java/com/facebook/react/views/drawer/events/DrawerClosedEvent.java

@@ -33,10 +33,4 @@ public class DrawerClosedEvent extends Event<DrawerClosedEvent> {
   protected WritableMap getEventData() {
     return Arguments.createMap();
   }
-
-  @Override
-  public short getCoalescingKey() {
-    // All events for a given view can be coalesced.
-    return 0;
-  }
 }