Adds support for page up, page down, move home, and move end key events.

Bug: 205800548
Test: Added additional unit tests.
Change-Id: I72cbba7bf0a0a3763755e3c23f4121ec9577e6ab

Author: Jeremy Walker

coordinatorlayout/coordinatorlayout/src/main/java/androidx/coordinatorlayout/widget/CoordinatorLayout.java

@@ -115,6 +115,8 @@ public class CoordinatorLayout extends ViewGroup implements NestedScrollingParen
         NestedScrollingParent3 {
     static final String TAG = "CoordinatorLayout";
     static final String WIDGET_PACKAGE_NAME;
+    // For the UP/DOWN keys, we scroll 1/10th of the screen.
+    private static final float KEY_SCROLL_FRACTION_AMOUNT = 0.1f;
 
     static {
         final Package pkg = CoordinatorLayout.class.getPackage();
@@ -181,6 +183,13 @@ private static void releaseTempRect(@NonNull Rect rect) {
     // This only exist to prevent GC and object instantiation costs that are present before API 21.
     private final int[] mNestedScrollingV2ConsumedCompat = new int[2];
 
+    // Array to be mutated by calls to nested scrolling related methods triggered by key events.
+    // Because these scrolling events rely on lower level methods using mBehaviorConsumed, we need
+    // a separate variable to save memory. As with the above, this only exist to prevent GC and
+    // object instantiation costs that are
+    // present before API 21.
+    private final int[] mKeyTriggeredScrollConsumed = new int[2];
+
     private boolean mDisallowInterceptReset;
 
     private boolean mIsAttachedToWindow;
@@ -1945,47 +1954,46 @@ public boolean dispatchKeyEvent(
             if (event.getAction() == KeyEvent.ACTION_DOWN) {
                 switch (event.getKeyCode()) {
                     case KeyEvent.KEYCODE_DPAD_UP:
-                    case KeyEvent.KEYCODE_DPAD_DOWN:
-                    case KeyEvent.KEYCODE_SPACE:
-
-                        int yScrollDelta;
-
-                        if (event.getKeyCode() == KeyEvent.KEYCODE_SPACE) {
-                            if (event.isShiftPressed()) {
-                                // Places the CoordinatorLayout at the top of the available
-                                // content.
-                                // Note: The delta may represent a value that would overshoot the
-                                // top of the screen, but the children only use as much of the
-                                // delta as they can support, so it will always go exactly to the
-                                // top.
-                                yScrollDelta = -getFullContentHeight();
-                            } else {
-                                // Places the CoordinatorLayout at the bottom of the available
-                                // content.
-                                yScrollDelta = getFullContentHeight() - getHeight();
-                            }
-
-                        } else if (event.isAltPressed()) { // For UP and DOWN KeyEvents
-                            // Full page scroll
-                            yScrollDelta = getHeight();
+                        if (event.isAltPressed()) {
+                            // Inverse to move up the screen
+                            handled = moveVertically(-pageDelta());
+                        } else {
+                            // Inverse to move up the screen
+                            handled = moveVertically(-lineDelta());
+                        }
+                        break;
 
+                    case KeyEvent.KEYCODE_DPAD_DOWN:
+                        if (event.isAltPressed()) {
+                            handled = moveVertically(pageDelta());
                         } else {
-                            // Regular arrow scroll
-                            yScrollDelta = (int) (getHeight() * 0.1f);
+                            handled = moveVertically(lineDelta());
                         }
+                        break;
+
+                    case KeyEvent.KEYCODE_PAGE_UP:
+                        // Inverse to move up the screen
+                        handled = moveVertically(-pageDelta());
+                        break;
 
-                        View focusedView = findDeepestFocusedChild(this);
+                    case KeyEvent.KEYCODE_PAGE_DOWN:
+                        handled = moveVertically(pageDelta());
+                        break;
 
-                        // Convert delta to negative if the key event is UP.
-                        if (event.getKeyCode() == KeyEvent.KEYCODE_DPAD_UP) {
-                            yScrollDelta = -yScrollDelta;
+                    case KeyEvent.KEYCODE_SPACE:
+                        if (event.isShiftPressed()) {
+                            handled = moveVertically(distanceToTop());
+                        } else {
+                            handled = moveVertically(distanceToBottom());
                         }
+                        break;
 
-                        handled = manuallyTriggersNestedScrollFromKeyEvent(
-                                focusedView,
-                                yScrollDelta
-                        );
+                    case KeyEvent.KEYCODE_MOVE_HOME:
+                        handled = moveVertically(distanceToTop());
+                        break;
 
+                    case KeyEvent.KEYCODE_MOVE_END:
+                        handled = moveVertically(distanceToBottom());
                         break;
                 }
             }
@@ -1994,6 +2002,36 @@ public boolean dispatchKeyEvent(
         return handled;
     }
 
+    // Distance for moving one arrow key tap.
+    private int lineDelta() {
+        return (int) (getHeight() * KEY_SCROLL_FRACTION_AMOUNT);
+    }
+
+    private int pageDelta() {
+        return getHeight();
+    }
+
+    private int distanceToTop() {
+        // Note: The delta may represent a value that would overshoot the
+        // top of the screen, but the children only use as much of the
+        // delta as they can support, so it will always go exactly to the
+        // top.
+        return -getFullContentHeight();
+    }
+
+    private int distanceToBottom() {
+        return getFullContentHeight() - getHeight();
+    }
+
+    private boolean moveVertically(int yScrollDelta) {
+        View focusedView = findDeepestFocusedChild(this);
+
+        return manuallyTriggersNestedScrollFromKeyEvent(
+                focusedView,
+                yScrollDelta
+        );
+    }
+
     private View findDeepestFocusedChild(View startingParentView) {
         View focusedView = startingParentView;
         while (focusedView != null) {
@@ -2050,19 +2088,23 @@ private boolean manuallyTriggersNestedScrollFromKeyEvent(View focusedView, int y
                 ViewCompat.TYPE_NON_TOUCH
         );
 
+        // Reset consumed values to zero.
+        mKeyTriggeredScrollConsumed[0] = 0;
+        mKeyTriggeredScrollConsumed[1] = 0;
+
         onNestedScroll(
                 focusedView,
                 0,
                 0,
                 0,
                 yScrollDelta,
                 ViewCompat.TYPE_NON_TOUCH,
-                mBehaviorConsumed
+                mKeyTriggeredScrollConsumed
         );
 
         onStopNestedScroll(focusedView, ViewCompat.TYPE_NON_TOUCH);
 
-        if (mBehaviorConsumed[1] > 0) {
+        if (mKeyTriggeredScrollConsumed[1] > 0) {
             handled = true;
         }