react-native 0.66.2 → 0.67.0-rc.3

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

@@ -13,6 +13,7 @@ import androidx.core.util.Pools;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.SoftAssertions;
+import com.facebook.react.config.ReactFeatureFlags;
 
 /**
  * An event representing the start, end or movement of a touch. Corresponds to a single {@link
@@ -96,7 +97,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");
@@ -188,17 +189,47 @@ public class TouchEvent extends Event<TouchEvent> {
               "Cannot dispatch a TouchEvent that has no MotionEvent; the TouchEvent has been recycled"));
       return;
     }
-    TouchesHelper.sendTouchEvent(
-        rctEventEmitter,
-        Assertions.assertNotNull(mTouchEventType),
-        getSurfaceId(),
-        getViewTag(),
-        this);
+
+    TouchesHelper.sendTouchEvent(rctEventEmitter, this);
   }
 
   @Override
   public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
-    dispatch(rctEventEmitter);
+    if (ReactFeatureFlags.useUpdatedTouchPreprocessing) {
+      TouchesHelper.sendTouchEventModern(rctEventEmitter, this, /* useDispatchV2 */ false);
+    } else {
+      dispatch(rctEventEmitter);
+    }
+  }
+
+  @Override
+  public void dispatchModernV2(RCTModernEventEmitter rctEventEmitter) {
+    if (ReactFeatureFlags.useUpdatedTouchPreprocessing) {
+      TouchesHelper.sendTouchEventModern(rctEventEmitter, this, /* useDispatchV2 */ true);
+    } else {
+      dispatch(rctEventEmitter);
+    }
+  }
+
+  @Override
+  protected int getEventCategory() {
+    TouchEventType type = mTouchEventType;
+    if (type == null) {
+      return EventCategoryDef.UNSPECIFIED;
+    }
+
+    switch (type) {
+      case START:
+        return EventCategoryDef.CONTINUOUS_START;
+      case END:
+      case CANCEL:
+        return EventCategoryDef.CONTINUOUS_END;
+      case MOVE:
+        return EventCategoryDef.CONTINUOUS;
+    }
+
+    // Something something smart compiler...
+    return super.getEventCategory();
   }
 
   public MotionEvent getMotionEvent() {
@@ -210,6 +241,10 @@ public class TouchEvent extends Event<TouchEvent> {
     return mMotionEvent != null;
   }
 
+  public TouchEventType getTouchEventType() {
+    return Assertions.assertNotNull(mTouchEventType);
+  }
+
   public float getViewX() {
     return mViewX;
   }

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

@@ -9,23 +9,22 @@ package com.facebook.react.uimanager.events;
 
 /** Touch event types that JS module RCTEventEmitter can understand */
 public enum TouchEventType {
-  START,
-  END,
-  MOVE,
-  CANCEL;
+  START("topTouchStart"),
+  END("topTouchEnd"),
+  MOVE("topTouchMove"),
+  CANCEL("topTouchCancel");
+
+  private final String mJsName;
+
+  TouchEventType(String jsName) {
+    mJsName = jsName;
+  }
+
+  public String getJsName() {
+    return mJsName;
+  }
 
   public static String getJSEventName(TouchEventType type) {
-    switch (type) {
-      case START:
-        return "topTouchStart";
-      case END:
-        return "topTouchEnd";
-      case MOVE:
-        return "topTouchMove";
-      case CANCEL:
-        return "topTouchCancel";
-      default:
-        throw new IllegalArgumentException("Unexpected type " + type);
-    }
+    return type.getJsName();
   }
 }

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

@@ -9,19 +9,17 @@ package com.facebook.react.uimanager.events;
 
 import android.view.MotionEvent;
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.PixelUtil;
 
 /** Class responsible for generating catalyst touch events based on android {@link MotionEvent}. */
 public class TouchesHelper {
-
   public static final String TARGET_SURFACE_KEY = "targetSurface";
   public static final String TARGET_KEY = "target";
   public static final String CHANGED_TOUCHES_KEY = "changedTouches";
   public static final String TOUCHES_KEY = "touches";
-  public static final String TOP_TOUCH_END_KEY = "topTouchEnd";
-  public static final String TOP_TOUCH_CANCEL_KEY = "topTouchCancel";
   private static final String PAGE_X_KEY = "pageX";
   private static final String PAGE_Y_KEY = "pageY";
   private static final String TIMESTAMP_KEY = "timestamp";
@@ -30,15 +28,16 @@ public class TouchesHelper {
   private static final String LOCATION_X_KEY = "locationX";
   private static final String LOCATION_Y_KEY = "locationY";
 
+  private static final String TAG = "TouchesHelper";
+
   /**
    * Creates catalyst pointers array in format that is expected by RCTEventEmitter JS module from
    * given {@param event} instance. This method use {@param reactTarget} parameter to set as a
    * target view id associated with current gesture.
    */
-  private static WritableArray createsPointersArray(
-      int surfaceId, int reactTarget, TouchEvent event) {
-    WritableArray touches = Arguments.createArray();
+  private static WritableMap[] createPointersArray(TouchEvent event) {
     MotionEvent motionEvent = event.getMotionEvent();
+    WritableMap[] touches = new WritableMap[motionEvent.getPointerCount()];
 
     // Calculate the coordinates for the target view.
     // The MotionEvent contains the X,Y of the touch in the coordinate space of the root view
@@ -62,11 +61,12 @@ public class TouchesHelper {
       float locationY = motionEvent.getY(index) - targetViewCoordinateY;
       touch.putDouble(LOCATION_X_KEY, PixelUtil.toDIPFromPixel(locationX));
       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.putInt(TARGET_SURFACE_KEY, event.getSurfaceId());
+      touch.putInt(TARGET_KEY, event.getViewTag());
+      touch.putDouble(TIMESTAMP_KEY, event.getTimestampMs());
       touch.putDouble(POINTER_IDENTIFIER_KEY, motionEvent.getPointerId(index));
-      touches.pushMap(touch);
+
+      touches[index] = touch;
     }
 
     return touches;
@@ -77,17 +77,12 @@ public class TouchesHelper {
    * context}. Touch event can encode multiple concurrent touches (pointers).
    *
    * @param rctEventEmitter Event emitter used to execute JS module call
-   * @param type type of the touch event (see {@link TouchEventType})
-   * @param reactTarget target view react id associated with this gesture
    * @param touchEvent native touch event to read pointers count and coordinates from
    */
-  public static void sendTouchEvent(
-      RCTEventEmitter rctEventEmitter,
-      TouchEventType type,
-      int surfaceId,
-      int reactTarget,
-      TouchEvent touchEvent) {
-    WritableArray pointers = createsPointersArray(surfaceId, reactTarget, touchEvent);
+  public static void sendTouchEvent(RCTEventEmitter rctEventEmitter, TouchEvent touchEvent) {
+    TouchEventType type = touchEvent.getTouchEventType();
+
+    WritableArray pointers = getWritableArray(createPointersArray(touchEvent));
     MotionEvent motionEvent = touchEvent.getMotionEvent();
 
     // For START and END events send only index of the pointer that is associated with that event
@@ -105,4 +100,98 @@ public class TouchesHelper {
 
     rctEventEmitter.receiveTouches(TouchEventType.getJSEventName(type), pointers, changedIndices);
   }
+
+  /**
+   * Generate touch event data to match JS expectations. Combines logic in {@link #sendTouchEvent}
+   * and FabricEventEmitter to create the same data structure in a more efficient manner.
+   *
+   * <p>Touches have to be dispatched as separate events for each changed pointer to make JS process
+   * them correctly. To avoid allocations, we preprocess touch events in Java world and then convert
+   * them to native before dispatch.
+   *
+   * @param eventEmitter emitter to dispatch event to
+   * @param event the touch event to extract data from
+   * @param useDispatchV2 whether to dispatch additional data used by {@link Event#dispatchModernV2}
+   */
+  public static void sendTouchEventModern(
+      RCTModernEventEmitter eventEmitter, TouchEvent event, boolean useDispatchV2) {
+    TouchEventType type = event.getTouchEventType();
+    MotionEvent motionEvent = event.getMotionEvent();
+
+    if (motionEvent == null) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException(
+              "Cannot dispatch a TouchEvent that has no MotionEvent; the TouchEvent has been recycled"));
+      return;
+    }
+
+    WritableMap[] touches = createPointersArray(event);
+    WritableMap[] changedTouches = null;
+
+    switch (type) {
+      case START:
+        int newPointerIndex = motionEvent.getActionIndex();
+
+        changedTouches = new WritableMap[] {touches[newPointerIndex].copy()};
+        break;
+      case END:
+        int finishedPointerIndex = motionEvent.getActionIndex();
+        /*
+         * Clear finished pointer index for compatibility with W3C touch "end" events, where the
+         * active touches don't include the set that has just been "ended".
+         */
+        WritableMap finishedPointer = touches[finishedPointerIndex];
+        touches[finishedPointerIndex] = null;
+
+        changedTouches = new WritableMap[] {finishedPointer};
+        break;
+      case MOVE:
+        changedTouches = new WritableMap[touches.length];
+        for (int i = 0; i < touches.length; i++) {
+          changedTouches[i] = touches[i].copy();
+        }
+        break;
+      case CANCEL:
+        changedTouches = touches;
+        touches = new WritableMap[0];
+        break;
+    }
+
+    WritableArray touchesArray = getWritableArray(touches);
+    WritableArray changedTouchesArray = getWritableArray(/* copyObjects */ true, changedTouches);
+
+    for (WritableMap eventData : changedTouches) {
+      eventData.putArray(CHANGED_TOUCHES_KEY, changedTouchesArray);
+      eventData.putArray(TOUCHES_KEY, touchesArray);
+
+      if (useDispatchV2) {
+        eventEmitter.receiveEvent(
+            event.getSurfaceId(),
+            event.getViewTag(),
+            event.getEventName(),
+            event.canCoalesce(),
+            0,
+            eventData,
+            event.getEventCategory());
+      } else {
+        eventEmitter.receiveEvent(
+            event.getSurfaceId(), event.getViewTag(), event.getEventName(), eventData);
+      }
+    }
+  }
+
+  private static WritableArray getWritableArray(WritableMap... objects) {
+    return getWritableArray(false, objects);
+  }
+
+  private static WritableArray getWritableArray(boolean copyObjects, WritableMap... objects) {
+    WritableArray result = Arguments.createArray();
+    for (WritableMap object : objects) {
+      if (object != null) {
+        result.pushMap(copyObjects ? object.copy() : object);
+      }
+    }
+    return result;
+  }
 }

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

@@ -11,12 +11,6 @@ rn_xplat_cxx_library(
         ],
         prefix = "react/uimanager/jni",
     ),
-    compiler_flags = [
-        "-fexceptions",
-        "-frtti",
-        "-std=c++17",
-        "-Wall",
-    ],
     fbandroid_allow_jni_merging = True,
     labels = ["supermodule:xplat/default/public.react_native.infra"],
     platforms = ANDROID,

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollView.java

@@ -7,6 +7,12 @@
 
 package com.facebook.react.views.scroll;
 
+import static com.facebook.react.config.ReactFeatureFlags.enableScrollViewSnapToAlignmentProp;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_CENTER;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START;
+
 import android.animation.Animator;
 import android.animation.ObjectAnimator;
 import android.animation.PropertyValuesHolder;
@@ -21,6 +27,7 @@ import android.view.FocusFinder;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
+import android.view.ViewGroup;
 import android.view.accessibility.AccessibilityEvent;
 import android.widget.HorizontalScrollView;
 import android.widget.OverScroller;
@@ -94,6 +101,7 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
   private @Nullable List<Integer> mSnapOffsets;
   private boolean mSnapToStart = true;
   private boolean mSnapToEnd = true;
+  private int mSnapToAlignment = SNAP_ALIGNMENT_DISABLED;
   private ReactViewBackgroundManager mReactBackgroundManager;
   private boolean mPagedArrowScrolling = false;
   private int pendingContentOffsetX = UNSET_CONTENT_OFFSET;
@@ -239,6 +247,10 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     mSnapToEnd = snapToEnd;
   }
 
+  public void setSnapToAlignment(int snapToAlignment) {
+    mSnapToAlignment = snapToAlignment;
+  }
+
   public void flashScrollIndicators() {
     awakenScrollBars();
   }
@@ -905,7 +917,9 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
 
     // pagingEnabled only allows snapping one interval at a time
-    if (mSnapInterval == 0 && mSnapOffsets == null) {
+    if (mSnapInterval == 0
+        && mSnapOffsets == null
+        && (!enableScrollViewSnapToAlignmentProp || mSnapToAlignment == SNAP_ALIGNMENT_DISABLED)) {
       smoothScrollAndSnap(velocityX);
       return;
     }
@@ -948,8 +962,46 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
           }
         }
       }
+    } else if (enableScrollViewSnapToAlignmentProp && mSnapToAlignment != SNAP_ALIGNMENT_DISABLED) {
+      if (mSnapInterval > 0) {
+        double ratio = (double) targetOffset / mSnapInterval;
+        smallerOffset =
+            Math.max(
+                getItemStartOffset(
+                    mSnapToAlignment,
+                    (int) (Math.floor(ratio) * mSnapInterval),
+                    mSnapInterval,
+                    width),
+                0);
+        largerOffset =
+            Math.min(
+                getItemStartOffset(
+                    mSnapToAlignment,
+                    (int) (Math.ceil(ratio) * mSnapInterval),
+                    mSnapInterval,
+                    width),
+                maximumOffset);
+      } else {
+        ViewGroup contentView = (ViewGroup) getContentView();
+        for (int i = 1; i < contentView.getChildCount(); i++) {
+          View item = contentView.getChildAt(i);
+          int itemStartOffset =
+              getItemStartOffset(mSnapToAlignment, item.getLeft(), item.getWidth(), width);
+          if (itemStartOffset <= targetOffset) {
+            if (targetOffset - itemStartOffset < targetOffset - smallerOffset) {
+              smallerOffset = itemStartOffset;
+            }
+          }
+
+          if (itemStartOffset >= targetOffset) {
+            if (itemStartOffset - targetOffset < largerOffset - targetOffset) {
+              largerOffset = itemStartOffset;
+            }
+          }
+        }
+      }
     } else {
-      double interval = (double) getSnapInterval();
+      double interval = getSnapInterval();
       double ratio = (double) targetOffset / interval;
       smallerOffset = (int) (Math.floor(ratio) * interval);
       largerOffset = Math.min((int) (Math.ceil(ratio) * interval), maximumOffset);
@@ -1032,6 +1084,25 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
   }
 
+  private int getItemStartOffset(
+      int snapToAlignment, int itemStartPosition, int itemWidth, int viewPortWidth) {
+    int itemStartOffset;
+    switch (snapToAlignment) {
+      case SNAP_ALIGNMENT_CENTER:
+        itemStartOffset = itemStartPosition - (viewPortWidth - itemWidth) / 2;
+        break;
+      case SNAP_ALIGNMENT_START:
+        itemStartOffset = itemStartPosition;
+        break;
+      case SNAP_ALIGNMENT_END:
+        itemStartOffset = itemStartPosition - (viewPortWidth - itemWidth);
+        break;
+      default:
+        throw new IllegalStateException("Invalid SnapToAlignment value: " + mSnapToAlignment);
+    }
+    return itemStartOffset;
+  }
+
   private void smoothScrollToNextPage(int direction) {
     if (DEBUG_MODE) {
       FLog.i(TAG, "smoothScrollToNextPage[%d] direction %d", getId(), direction);
@@ -1160,8 +1231,12 @@ public class ReactHorizontalScrollView extends HorizontalScrollView
     }
 
     super.scrollTo(x, y);
-    updateStateOnScroll(x, y);
-    setPendingContentOffsets(x, y);
+    // The final scroll position might be different from (x, y). For example, we may need to scroll
+    // to the last item in the list, but that item cannot be move to the start position of the view.
+    final int actualX = getScrollX();
+    final int actualY = getScrollY();
+    updateStateOnScroll(actualX, actualY);
+    setPendingContentOffsets(actualX, actualY);
   }
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactHorizontalScrollViewManager.java

@@ -102,6 +102,11 @@ public class ReactHorizontalScrollViewManager extends ViewGroupManager<ReactHori
     view.setSnapInterval((int) (snapToInterval * screenDisplayMetrics.density));
   }
 
+  @ReactProp(name = "snapToAlignment")
+  public void setSnapToAlignment(ReactHorizontalScrollView view, String alignment) {
+    view.setSnapToAlignment(ReactScrollViewHelper.parseSnapToAlignment(alignment));
+  }
+
   @ReactProp(name = "snapToOffsets")
   public void setSnapToOffsets(
       ReactHorizontalScrollView view, @Nullable ReadableArray snapToOffsets) {

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollView.java

@@ -7,6 +7,12 @@
 
 package com.facebook.react.views.scroll;
 
+import static com.facebook.react.config.ReactFeatureFlags.enableScrollViewSnapToAlignmentProp;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_CENTER;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_DISABLED;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_END;
+import static com.facebook.react.views.scroll.ReactScrollViewHelper.SNAP_ALIGNMENT_START;
+
 import android.animation.Animator;
 import android.animation.ObjectAnimator;
 import android.animation.PropertyValuesHolder;
@@ -92,6 +98,7 @@ public class ReactScrollView extends ScrollView
   private @Nullable List<Integer> mSnapOffsets;
   private boolean mSnapToStart = true;
   private boolean mSnapToEnd = true;
+  private int mSnapToAlignment = SNAP_ALIGNMENT_DISABLED;
   private @Nullable View mContentView;
   private ReactViewBackgroundManager mReactBackgroundManager;
   private int pendingContentOffsetX = UNSET_CONTENT_OFFSET;
@@ -218,6 +225,10 @@ public class ReactScrollView extends ScrollView
     mSnapToEnd = snapToEnd;
   }
 
+  public void setSnapToAlignment(int snapToAlignment) {
+    mSnapToAlignment = snapToAlignment;
+  }
+
   public void flashScrollIndicators() {
     awakenScrollBars();
   }
@@ -634,6 +645,10 @@ public class ReactScrollView extends ScrollView
     return scroller.getFinalY();
   }
 
+  private View getContentView() {
+    return getChildAt(0);
+  }
+
   /**
    * This will smooth scroll us to the nearest snap offset point It currently just looks at where
    * the content is and slides to the nearest point. It is intended to be run after we are done
@@ -690,7 +705,9 @@ public class ReactScrollView extends ScrollView
     }
 
     // pagingEnabled only allows snapping one interval at a time
-    if (mSnapInterval == 0 && mSnapOffsets == null) {
+    if (mSnapInterval == 0
+        && mSnapOffsets == null
+        && (!enableScrollViewSnapToAlignmentProp || mSnapToAlignment == SNAP_ALIGNMENT_DISABLED)) {
       smoothScrollAndSnap(velocityY);
       return;
     }
@@ -727,6 +744,57 @@ public class ReactScrollView extends ScrollView
           }
         }
       }
+
+    } else if (enableScrollViewSnapToAlignmentProp && mSnapToAlignment != SNAP_ALIGNMENT_DISABLED) {
+      if (mSnapInterval > 0) {
+        double ratio = (double) targetOffset / mSnapInterval;
+        smallerOffset =
+            Math.max(
+                getItemStartOffset(
+                    mSnapToAlignment,
+                    (int) (Math.floor(ratio) * mSnapInterval),
+                    mSnapInterval,
+                    height),
+                0);
+        largerOffset =
+            Math.min(
+                getItemStartOffset(
+                    mSnapToAlignment,
+                    (int) (Math.ceil(ratio) * mSnapInterval),
+                    mSnapInterval,
+                    height),
+                maximumOffset);
+      } else {
+        ViewGroup contentView = (ViewGroup) getContentView();
+        for (int i = 1; i < contentView.getChildCount(); i++) {
+          View item = contentView.getChildAt(i);
+          int itemStartOffset;
+          switch (mSnapToAlignment) {
+            case SNAP_ALIGNMENT_CENTER:
+              itemStartOffset = item.getTop() - (height - item.getHeight()) / 2;
+              break;
+            case SNAP_ALIGNMENT_START:
+              itemStartOffset = item.getTop();
+              break;
+            case SNAP_ALIGNMENT_END:
+              itemStartOffset = item.getTop() - (height - item.getHeight());
+              break;
+            default:
+              throw new IllegalStateException("Invalid SnapToAlignment value: " + mSnapToAlignment);
+          }
+          if (itemStartOffset <= targetOffset) {
+            if (targetOffset - itemStartOffset < targetOffset - smallerOffset) {
+              smallerOffset = itemStartOffset;
+            }
+          }
+
+          if (itemStartOffset >= targetOffset) {
+            if (itemStartOffset - targetOffset < largerOffset - targetOffset) {
+              largerOffset = itemStartOffset;
+            }
+          }
+        }
+      }
     } else {
       double interval = (double) getSnapInterval();
       double ratio = (double) targetOffset / interval;
@@ -802,6 +870,25 @@ public class ReactScrollView extends ScrollView
     }
   }
 
+  private int getItemStartOffset(
+      int snapToAlignment, int itemStartPosition, int itemHeight, int viewPortHeight) {
+    int itemStartOffset;
+    switch (snapToAlignment) {
+      case SNAP_ALIGNMENT_CENTER:
+        itemStartOffset = itemStartPosition - (viewPortHeight - itemHeight) / 2;
+        break;
+      case SNAP_ALIGNMENT_START:
+        itemStartOffset = itemStartPosition;
+        break;
+      case SNAP_ALIGNMENT_END:
+        itemStartOffset = itemStartPosition - (viewPortHeight - itemHeight);
+        break;
+      default:
+        throw new IllegalStateException("Invalid SnapToAlignment value: " + mSnapToAlignment);
+    }
+    return itemStartOffset;
+  }
+
   private int getSnapInterval() {
     if (mSnapInterval != 0) {
       return mSnapInterval;
@@ -919,8 +1006,12 @@ public class ReactScrollView extends ScrollView
   @Override
   public void scrollTo(int x, int y) {
     super.scrollTo(x, y);
-    updateStateOnScroll(x, y);
-    setPendingContentOffsets(x, y);
+    // The final scroll position might be different from (x, y). For example, we may need to scroll
+    // to the last item in the list, but that item cannot be move to the start position of the view.
+    final int actualX = getScrollX();
+    final int actualY = getScrollY();
+    updateStateOnScroll(actualX, actualY);
+    setPendingContentOffsets(actualX, actualY);
   }
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewHelper.java

@@ -11,6 +11,7 @@ import android.content.Context;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.OverScroller;
+import androidx.annotation.Nullable;
 import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
@@ -26,6 +27,11 @@ public class ReactScrollViewHelper {
   public static final String AUTO = "auto";
   public static final String OVER_SCROLL_NEVER = "never";
 
+  public static final int SNAP_ALIGNMENT_DISABLED = 0;
+  public static final int SNAP_ALIGNMENT_START = 1;
+  public static final int SNAP_ALIGNMENT_CENTER = 2;
+  public static final int SNAP_ALIGNMENT_END = 3;
+
   public interface ScrollListener {
     void onScroll(
         ViewGroup scrollView, ScrollEventType scrollEventType, float xVelocity, float yVelocity);
@@ -34,7 +40,7 @@ public class ReactScrollViewHelper {
   }
 
   // Support global native listeners for scroll events
-  private static Set<ScrollListener> sScrollListeners =
+  private static final Set<ScrollListener> sScrollListeners =
       Collections.newSetFromMap(new WeakHashMap<ScrollListener, Boolean>());
 
   // If all else fails, this is the hardcoded value in OverScroller.java, in AOSP.
@@ -119,6 +125,20 @@ public class ReactScrollViewHelper {
     }
   }
 
+  public static int parseSnapToAlignment(@Nullable String alignment) {
+    if (alignment == null) {
+      return SNAP_ALIGNMENT_DISABLED;
+    } else if ("start".equalsIgnoreCase(alignment)) {
+      return SNAP_ALIGNMENT_START;
+    } else if ("center".equalsIgnoreCase(alignment)) {
+      return SNAP_ALIGNMENT_CENTER;
+    } else if ("end".equals(alignment)) {
+      return SNAP_ALIGNMENT_END;
+    } else {
+      throw new JSApplicationIllegalArgumentException("wrong snap alignment value: " + alignment);
+    }
+  }
+
   public static int getDefaultScrollAnimationDuration(Context context) {
     if (!mSmoothScrollDurationInitialized) {
       mSmoothScrollDurationInitialized = true;

package/ReactAndroid/src/main/java/com/facebook/react/views/scroll/ReactScrollViewManager.java

@@ -115,6 +115,11 @@ public class ReactScrollViewManager extends ViewGroupManager<ReactScrollView>
     view.setSnapOffsets(offsets);
   }
 
+  @ReactProp(name = "snapToAlignment")
+  public void setSnapToAlignment(ReactScrollView view, String alignment) {
+    view.setSnapToAlignment(ReactScrollViewHelper.parseSnapToAlignment(alignment));
+  }
+
   @ReactProp(name = "snapToStart")
   public void setSnapToStart(ReactScrollView view, boolean snapToStart) {
     view.setSnapToStart(snapToStart);

package/ReactAndroid/src/main/java/com/facebook/react/views/text/ReactTextAnchorViewManager.java

@@ -110,10 +110,6 @@ public abstract class ReactTextAnchorViewManager<T extends View, C extends React
       view.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NONE);
     } else if (frequency.equals("full")) {
       view.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_FULL);
-    } else if (frequency.equals("balanced")) {
-      view.setHyphenationFrequency(Layout.BREAK_STRATEGY_BALANCED);
-    } else if (frequency.equals("high")) {
-      view.setHyphenationFrequency(Layout.BREAK_STRATEGY_HIGH_QUALITY);
     } else if (frequency.equals("normal")) {
       view.setHyphenationFrequency(Layout.HYPHENATION_FREQUENCY_NORMAL);
     } else {