Improve scrolling in key view

1 files changed, 1355 insertions, 0 deletions

diff --git a/OpenKeychain/src/main/java/android/support/v4/widget/FlingNestedScrollView.java b/OpenKeychain/src/main/java/android/support/v4/widget/FlingNestedScrollView.java
new file mode 100644
index 000000000..2bfda5fa8
--- /dev/null
+++ b/OpenKeychain/src/main/java/android/support/v4/widget/FlingNestedScrollView.java
@@ -0,0 +1,1355 @@
+/*
+ * Copyright (C) 2015 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.support.v4.widget;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.v4.view.AccessibilityDelegateCompat;
+import android.support.v4.view.MotionEventCompat;
+import android.support.v4.view.NestedScrollingChild;
+import android.support.v4.view.NestedScrollingChildHelper;
+import android.support.v4.view.NestedScrollingParent;
+import android.support.v4.view.NestedScrollingParentHelper;
+import android.support.v4.view.VelocityTrackerCompat;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.accessibility.AccessibilityEventCompat;
+import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
+import android.support.v4.view.accessibility.AccessibilityRecordCompat;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.FocusFinder;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+import android.widget.FrameLayout;
+import android.widget.ScrollView;
+
+import java.util.ArrayList;
+
+/**
+ * Workaround for bug in support lib. From https://code.google.com/p/android/issues/detail?id=177729
+ *
+ * Also see workaround with padding in view_key_fragment.xml
+ */
+public class FlingNestedScrollView extends FrameLayout implements NestedScrollingParent, NestedScrollingChild {
+    static final int ANIMATED_SCROLL_GAP = 250;
+    static final float MAX_SCROLL_FACTOR = 0.5F;
+    private static final String TAG = "FlingNestedScrollView";
+    private long mLastScroll;
+    private final Rect mTempRect;
+    private ScrollerCompat mScroller;
+    private EdgeEffectCompat mEdgeGlowTop;
+    private EdgeEffectCompat mEdgeGlowBottom;
+    private int mLastMotionY;
+    private boolean mIsLayoutDirty;
+    private boolean mIsLaidOut;
+    private View mChildToScrollTo;
+    private boolean mIsBeingDragged;
+    private VelocityTracker mVelocityTracker;
+    private boolean mFillViewport;
+    private boolean mSmoothScrollingEnabled;
+    private int mTouchSlop;
+    private int mMinimumVelocity;
+    private int mMaximumVelocity;
+    private int mActivePointerId;
+    private final int[] mScrollOffset;
+    private final int[] mScrollConsumed;
+    private int mNestedYOffset;
+    private static final int INVALID_POINTER = -1;
+    private FlingNestedScrollView.SavedState mSavedState;
+    private static final FlingNestedScrollView.AccessibilityDelegate ACCESSIBILITY_DELEGATE = new FlingNestedScrollView.AccessibilityDelegate();
+    private static final int[] SCROLLVIEW_STYLEABLE = new int[]{16843130};
+    private final NestedScrollingParentHelper mParentHelper;
+    private final NestedScrollingChildHelper mChildHelper;
+    private float mVerticalScrollFactor;
+
+    public FlingNestedScrollView(Context context) {
+        this(context, (AttributeSet)null);
+    }
+
+    public FlingNestedScrollView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public FlingNestedScrollView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+        this.mTempRect = new Rect();
+        this.mIsLayoutDirty = true;
+        this.mIsLaidOut = false;
+        this.mChildToScrollTo = null;
+        this.mIsBeingDragged = false;
+        this.mSmoothScrollingEnabled = true;
+        this.mActivePointerId = -1;
+        this.mScrollOffset = new int[2];
+        this.mScrollConsumed = new int[2];
+        this.initScrollView();
+        TypedArray a = context.obtainStyledAttributes(attrs, SCROLLVIEW_STYLEABLE, defStyleAttr, 0);
+        this.setFillViewport(a.getBoolean(0, false));
+        a.recycle();
+        this.mParentHelper = new NestedScrollingParentHelper(this);
+        this.mChildHelper = new NestedScrollingChildHelper(this);
+        this.setNestedScrollingEnabled(true);
+        ViewCompat.setAccessibilityDelegate(this, ACCESSIBILITY_DELEGATE);
+    }
+
+    public void setNestedScrollingEnabled(boolean enabled) {
+        this.mChildHelper.setNestedScrollingEnabled(enabled);
+    }
+
+    public boolean isNestedScrollingEnabled() {
+        return this.mChildHelper.isNestedScrollingEnabled();
+    }
+
+    public boolean startNestedScroll(int axes) {
+        return this.mChildHelper.startNestedScroll(axes);
+    }
+
+    public void stopNestedScroll() {
+        this.mChildHelper.stopNestedScroll();
+    }
+
+    public boolean hasNestedScrollingParent() {
+        return this.mChildHelper.hasNestedScrollingParent();
+    }
+
+    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int[] offsetInWindow) {
+        return this.mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow);
+    }
+
+    public boolean dispatchNestedPreScroll(int dx, int dy, int[] consumed, int[] offsetInWindow) {
+        return this.mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow);
+    }
+
+    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
+        return this.mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed);
+    }
+
+    public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
+        return this.mChildHelper.dispatchNestedPreFling(velocityX, velocityY);
+    }
+
+    public boolean onStartNestedScroll(View child, View target, int nestedScrollAxes) {
+        return (nestedScrollAxes & 2) != 0;
+    }
+
+    public void onNestedScrollAccepted(View child, View target, int nestedScrollAxes) {
+        this.mParentHelper.onNestedScrollAccepted(child, target, nestedScrollAxes);
+        this.startNestedScroll(2);
+    }
+
+    public void onStopNestedScroll(View target) {
+        this.stopNestedScroll();
+    }
+
+    public void onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed) {
+        int oldScrollY = this.getScrollY();
+        this.scrollBy(0, dyUnconsumed);
+        int myConsumed = this.getScrollY() - oldScrollY;
+        int myUnconsumed = dyUnconsumed - myConsumed;
+        this.dispatchNestedScroll(0, myConsumed, 0, myUnconsumed, (int[])null);
+    }
+
+    public void onNestedPreScroll(View target, int dx, int dy, int[] consumed) {
+    }
+
+    public boolean onNestedFling(View target, float velocityX, float velocityY, boolean consumed) {
+        if(!consumed) {
+            this.flingWithNestedDispatch((int)velocityY);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public boolean onNestedPreFling(View target, float velocityX, float velocityY) {
+        return false;
+    }
+
+    public int getNestedScrollAxes() {
+        return this.mParentHelper.getNestedScrollAxes();
+    }
+
+    public boolean shouldDelayChildPressedState() {
+        return true;
+    }
+
+    protected float getTopFadingEdgeStrength() {
+        if(this.getChildCount() == 0) {
+            return 0.0F;
+        } else {
+            int length = this.getVerticalFadingEdgeLength();
+            int scrollY = this.getScrollY();
+            return scrollY < length?(float)scrollY / (float)length:1.0F;
+        }
+    }
+
+    protected float getBottomFadingEdgeStrength() {
+        if(this.getChildCount() == 0) {
+            return 0.0F;
+        } else {
+            int length = this.getVerticalFadingEdgeLength();
+            int bottomEdge = this.getHeight() - this.getPaddingBottom();
+            int span = this.getChildAt(0).getBottom() - this.getScrollY() - bottomEdge;
+            return span < length?(float)span / (float)length:1.0F;
+        }
+    }
+
+    public int getMaxScrollAmount() {
+        return (int)(0.5F * (float)this.getHeight());
+    }
+
+    private void initScrollView() {
+        this.mScroller = new ScrollerCompat(this.getContext(), (Interpolator)null);
+        this.setFocusable(true);
+        //noinspection ResourceType
+        this.setDescendantFocusability(262144);
+        this.setWillNotDraw(false);
+        ViewConfiguration configuration = ViewConfiguration.get(this.getContext());
+        this.mTouchSlop = configuration.getScaledTouchSlop();
+        this.mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
+        this.mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
+    }
+
+    public void addView(View child) {
+        if(this.getChildCount() > 0) {
+            throw new IllegalStateException("ScrollView can host only one direct child");
+        } else {
+            super.addView(child);
+        }
+    }
+
+    public void addView(View child, int index) {
+        if(this.getChildCount() > 0) {
+            throw new IllegalStateException("ScrollView can host only one direct child");
+        } else {
+            super.addView(child, index);
+        }
+    }
+
+    public void addView(View child, LayoutParams params) {
+        if(this.getChildCount() > 0) {
+            throw new IllegalStateException("ScrollView can host only one direct child");
+        } else {
+            super.addView(child, params);
+        }
+    }
+
+    public void addView(View child, int index, LayoutParams params) {
+        if(this.getChildCount() > 0) {
+            throw new IllegalStateException("ScrollView can host only one direct child");
+        } else {
+            super.addView(child, index, params);
+        }
+    }
+
+    private boolean canScroll() {
+        View child = this.getChildAt(0);
+        if(child != null) {
+            int childHeight = child.getHeight();
+            return this.getHeight() < childHeight + this.getPaddingTop() + this.getPaddingBottom();
+        } else {
+            return false;
+        }
+    }
+
+    public boolean isFillViewport() {
+        return this.mFillViewport;
+    }
+
+    public void setFillViewport(boolean fillViewport) {
+        if(fillViewport != this.mFillViewport) {
+            this.mFillViewport = fillViewport;
+            this.requestLayout();
+        }
+
+    }
+
+    public boolean isSmoothScrollingEnabled() {
+        return this.mSmoothScrollingEnabled;
+    }
+
+    public void setSmoothScrollingEnabled(boolean smoothScrollingEnabled) {
+        this.mSmoothScrollingEnabled = smoothScrollingEnabled;
+    }
+
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+        if(this.mFillViewport) {
+            int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+            if(heightMode != 0) {
+                if(this.getChildCount() > 0) {
+                    View child = this.getChildAt(0);
+                    int height = this.getMeasuredHeight();
+                    if(child.getMeasuredHeight() < height) {
+                        android.widget.FrameLayout.LayoutParams lp = (android.widget.FrameLayout.LayoutParams)child.getLayoutParams();
+                        int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, this.getPaddingLeft() + this.getPaddingRight(), lp.width);
+                        height -= this.getPaddingTop();
+                        height -= this.getPaddingBottom();
+                        //noinspection ResourceType
+                        int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, 1073741824);
+                        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+                    }
+                }
+
+            }
+        }
+    }
+
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        return super.dispatchKeyEvent(event) || this.executeKeyEvent(event);
+    }
+
+    public boolean executeKeyEvent(KeyEvent event) {
+        this.mTempRect.setEmpty();
+        if(this.canScroll()) {
+            boolean handled1 = false;
+            if(event.getAction() == 0) {
+                switch(event.getKeyCode()) {
+                    case 19:
+                        if(!event.isAltPressed()) {
+                            handled1 = this.arrowScroll(33);
+                        } else {
+                            handled1 = this.fullScroll(33);
+                        }
+                        break;
+                    case 20:
+                        if(!event.isAltPressed()) {
+                            handled1 = this.arrowScroll(130);
+                        } else {
+                            handled1 = this.fullScroll(130);
+                        }
+                        break;
+                    case 62:
+                        this.pageScroll(event.isShiftPressed()?33:130);
+                }
+            }
+
+            return handled1;
+        } else if(this.isFocused() && event.getKeyCode() != 4) {
+            View handled = this.findFocus();
+            if(handled == this) {
+                handled = null;
+            }
+
+            View nextFocused = FocusFinder.getInstance().findNextFocus(this, handled, 130);
+            return nextFocused != null && nextFocused != this && nextFocused.requestFocus(130);
+        } else {
+            return false;
+        }
+    }
+
+    private boolean inChild(int x, int y) {
+        if(this.getChildCount() <= 0) {
+            return false;
+        } else {
+            int scrollY = this.getScrollY();
+            View child = this.getChildAt(0);
+            return y >= child.getTop() - scrollY && y < child.getBottom() - scrollY && x >= child.getLeft() && x < child.getRight();
+        }
+    }
+
+    private void initOrResetVelocityTracker() {
+        if(this.mVelocityTracker == null) {
+            this.mVelocityTracker = VelocityTracker.obtain();
+        } else {
+            this.mVelocityTracker.clear();
+        }
+
+    }
+
+    private void initVelocityTrackerIfNotExists() {
+        if(this.mVelocityTracker == null) {
+            this.mVelocityTracker = VelocityTracker.obtain();
+        }
+
+    }
+
+    private void recycleVelocityTracker() {
+        if(this.mVelocityTracker != null) {
+            this.mVelocityTracker.recycle();
+            this.mVelocityTracker = null;
+        }
+
+    }
+
+    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
+        if(disallowIntercept) {
+            this.recycleVelocityTracker();
+        }
+
+        super.requestDisallowInterceptTouchEvent(disallowIntercept);
+    }
+
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        int action = ev.getAction();
+        if(action == 2 && this.mIsBeingDragged) {
+            return true;
+        } else if(this.getScrollY() == 0 && !ViewCompat.canScrollVertically(this, 1)) {
+            return false;
+        } else {
+            int y;
+            switch(action & 255) {
+                case 0:
+                    y = (int)ev.getY();
+                    if(!this.inChild((int)ev.getX(), y)) {
+                        this.mIsBeingDragged = false;
+                        this.recycleVelocityTracker();
+                    } else {
+                        this.mLastMotionY = y;
+                        this.mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
+                        this.initOrResetVelocityTracker();
+                        this.mVelocityTracker.addMovement(ev);
+                        this.mIsBeingDragged = !this.mScroller.isFinished();
+                        this.startNestedScroll(2);
+                    }
+                    break;
+                case 1:
+                case 3:
+                    this.mIsBeingDragged = false;
+                    this.mActivePointerId = -1;
+                    this.recycleVelocityTracker();
+                    this.stopNestedScroll();
+                    break;
+                case 2:
+                    y = this.mActivePointerId;
+                    if(y != -1) {
+                        int pointerIndex = MotionEventCompat.findPointerIndex(ev, y);
+                        if(pointerIndex == -1) {
+                            Log.e("FlingNestedScrollView", "Invalid pointerId=" + y + " in onInterceptTouchEvent");
+                        } else {
+                            int y1 = (int)MotionEventCompat.getY(ev, pointerIndex);
+                            int yDiff = Math.abs(y1 - this.mLastMotionY);
+                            if(yDiff > this.mTouchSlop && (this.getNestedScrollAxes() & 2) == 0) {
+                                this.mIsBeingDragged = true;
+                                this.mLastMotionY = y1;
+                                this.initVelocityTrackerIfNotExists();
+                                this.mVelocityTracker.addMovement(ev);
+                                this.mNestedYOffset = 0;
+                                ViewParent parent = this.getParent();
+                                if(parent != null) {
+                                    parent.requestDisallowInterceptTouchEvent(true);
+                                }
+                            }
+                        }
+                    }
+                case 4:
+                case 5:
+                default:
+                    break;
+                case 6:
+                    this.onSecondaryPointerUp(ev);
+            }
+
+            return this.mIsBeingDragged;
+        }
+    }
+
+    public boolean onTouchEvent(MotionEvent ev) {
+        this.initVelocityTrackerIfNotExists();
+        MotionEvent vtev = MotionEvent.obtain(ev);
+        int actionMasked = MotionEventCompat.getActionMasked(ev);
+        if(actionMasked == 0) {
+            this.mNestedYOffset = 0;
+        }
+
+        vtev.offsetLocation(0.0F, (float)this.mNestedYOffset);
+        int index;
+        int initialVelocity;
+        switch(actionMasked) {
+            case 0:
+                if(this.getChildCount() == 0) {
+                    return false;
+                }
+
+                if(this.mIsBeingDragged = !this.mScroller.isFinished()) {
+                    ViewParent activePointerIndex1 = this.getParent();
+                    if(activePointerIndex1 != null) {
+                        activePointerIndex1.requestDisallowInterceptTouchEvent(true);
+                    }
+                }
+
+                if(!this.mScroller.isFinished()) {
+                    this.mScroller.abortAnimation();
+                }
+
+                this.mLastMotionY = (int)ev.getY();
+                this.mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
+                this.startNestedScroll(2);
+                break;
+            case 1:
+                if(this.mIsBeingDragged) {
+                    VelocityTracker index2 = this.mVelocityTracker;
+                    index2.computeCurrentVelocity(1000, (float)this.mMaximumVelocity);
+                    initialVelocity = (int) VelocityTrackerCompat.getYVelocity(index2, this.mActivePointerId);
+                    if(Math.abs(initialVelocity) > this.mMinimumVelocity) {
+                        this.flingWithNestedDispatch(-initialVelocity);
+                    }
+
+                    this.mActivePointerId = -1;
+                    this.endDrag();
+                }
+                break;
+            case 2:
+                int activePointerIndex = MotionEventCompat.findPointerIndex(ev, this.mActivePointerId);
+                if(activePointerIndex == -1) {
+                    Log.e("FlingNestedScrollView", "Invalid pointerId=" + this.mActivePointerId + " in onTouchEvent");
+                } else {
+                    int y = (int)MotionEventCompat.getY(ev, activePointerIndex);
+                    int deltaY = this.mLastMotionY - y;
+                    if(this.dispatchNestedPreScroll(0, deltaY, this.mScrollConsumed, this.mScrollOffset)) {
+                        deltaY -= this.mScrollConsumed[1];
+                        vtev.offsetLocation(0.0F, (float)this.mScrollOffset[1]);
+                        this.mNestedYOffset += this.mScrollOffset[1];
+                    }
+
+                    if(!this.mIsBeingDragged && Math.abs(deltaY) > this.mTouchSlop) {
+                        ViewParent index1 = this.getParent();
+                        if(index1 != null) {
+                            index1.requestDisallowInterceptTouchEvent(true);
+                        }
+
+                        this.mIsBeingDragged = true;
+                        if(deltaY > 0) {
+                            deltaY -= this.mTouchSlop;
+                        } else {
+                            deltaY += this.mTouchSlop;
+                        }
+                    }
+
+                    if(this.mIsBeingDragged) {
+                        this.mLastMotionY = y - this.mScrollOffset[1];
+                        index = this.getScrollY();
+                        initialVelocity = this.getScrollRange();
+                        int overscrollMode = ViewCompat.getOverScrollMode(this);
+                        boolean canOverscroll = overscrollMode == 0 || overscrollMode == 1 && initialVelocity > 0;
+                        if(this.overScrollByCompat(0, deltaY, 0, this.getScrollY(), 0, initialVelocity, 0, 0, true) && !this.hasNestedScrollingParent()) {
+                            this.mVelocityTracker.clear();
+                        }
+
+                        int scrolledDeltaY = this.getScrollY() - index;
+                        int unconsumedY = deltaY - scrolledDeltaY;
+                        if(this.dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, this.mScrollOffset)) {
+                            this.mLastMotionY -= this.mScrollOffset[1];
+                            vtev.offsetLocation(0.0F, (float)this.mScrollOffset[1]);
+                            this.mNestedYOffset += this.mScrollOffset[1];
+                        } else if(canOverscroll) {
+                            this.ensureGlows();
+                            int pulledToY = index + deltaY;
+                            if(pulledToY < 0) {
+                                this.mEdgeGlowTop.onPull((float)deltaY / (float)this.getHeight(), MotionEventCompat.getX(ev, activePointerIndex) / (float)this.getWidth());
+                                if(!this.mEdgeGlowBottom.isFinished()) {
+                                    this.mEdgeGlowBottom.onRelease();
+                                }
+                            } else if(pulledToY > initialVelocity) {
+                                this.mEdgeGlowBottom.onPull((float)deltaY / (float)this.getHeight(), 1.0F - MotionEventCompat.getX(ev, activePointerIndex) / (float)this.getWidth());
+                                if(!this.mEdgeGlowTop.isFinished()) {
+                                    this.mEdgeGlowTop.onRelease();
+                                }
+                            }
+
+                            if(this.mEdgeGlowTop != null && (!this.mEdgeGlowTop.isFinished() || !this.mEdgeGlowBottom.isFinished())) {
+                                ViewCompat.postInvalidateOnAnimation(this);
+                            }
+                        }
+                    }
+                }
+                break;
+            case 3:
+                if(this.mIsBeingDragged && this.getChildCount() > 0) {
+                    this.mActivePointerId = -1;
+                    this.endDrag();
+                }
+            case 4:
+            default:
+                break;
+            case 5:
+                index = MotionEventCompat.getActionIndex(ev);
+                this.mLastMotionY = (int)MotionEventCompat.getY(ev, index);
+                this.mActivePointerId = MotionEventCompat.getPointerId(ev, index);
+                break;
+            case 6:
+                this.onSecondaryPointerUp(ev);
+                this.mLastMotionY = (int)MotionEventCompat.getY(ev, MotionEventCompat.findPointerIndex(ev, this.mActivePointerId));
+        }
+
+        if(this.mVelocityTracker != null) {
+            this.mVelocityTracker.addMovement(vtev);
+        }
+
+        vtev.recycle();
+        return true;
+    }
+
+    private void onSecondaryPointerUp(MotionEvent ev) {
+        int pointerIndex = (ev.getAction() & '\uff00') >> 8;
+        int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
+        if(pointerId == this.mActivePointerId) {
+            int newPointerIndex = pointerIndex == 0?1:0;
+            this.mLastMotionY = (int)MotionEventCompat.getY(ev, newPointerIndex);
+            this.mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
+            if(this.mVelocityTracker != null) {
+                this.mVelocityTracker.clear();
+            }
+        }
+
+    }
+
+    public boolean onGenericMotionEvent(MotionEvent event) {
+        if((MotionEventCompat.getSource(event) & 2) != 0) {
+            switch(event.getAction()) {
+                case 8:
+                    if(!this.mIsBeingDragged) {
+                        float vscroll = MotionEventCompat.getAxisValue(event, 9);
+                        if(vscroll != 0.0F) {
+                            int delta = (int)(vscroll * this.getVerticalScrollFactorCompat());
+                            int range = this.getScrollRange();
+                            int oldScrollY = this.getScrollY();
+                            int newScrollY = oldScrollY - delta;
+                            if(newScrollY < 0) {
+                                newScrollY = 0;
+                            } else if(newScrollY > range) {
+                                newScrollY = range;
+                            }
+
+                            if(newScrollY != oldScrollY) {
+                                super.scrollTo(this.getScrollX(), newScrollY);
+                                return true;
+                            }
+                        }
+                    }
+            }
+        }
+
+        return false;
+    }
+
+    private float getVerticalScrollFactorCompat() {
+        if(this.mVerticalScrollFactor == 0.0F) {
+            TypedValue outValue = new TypedValue();
+            Context context = this.getContext();
+            if(!context.getTheme().resolveAttribute(16842829, outValue, true)) {
+                throw new IllegalStateException("Expected theme to define listPreferredItemHeight.");
+            }
+
+            this.mVerticalScrollFactor = outValue.getDimension(context.getResources().getDisplayMetrics());
+        }
+
+        return this.mVerticalScrollFactor;
+    }
+
+    protected void onOverScrolled(int scrollX, int scrollY, boolean clampedX, boolean clampedY) {
+        super.scrollTo(scrollX, scrollY);
+    }
+
+    boolean overScrollByCompat(int deltaX, int deltaY, int scrollX, int scrollY, int scrollRangeX, int scrollRangeY, int maxOverScrollX, int maxOverScrollY, boolean isTouchEvent) {
+        int overScrollMode = ViewCompat.getOverScrollMode(this);
+        boolean canScrollHorizontal = this.computeHorizontalScrollRange() > this.computeHorizontalScrollExtent();
+        boolean canScrollVertical = this.computeVerticalScrollRange() > this.computeVerticalScrollExtent();
+        boolean overScrollHorizontal = overScrollMode == 0 || overScrollMode == 1 && canScrollHorizontal;
+        boolean overScrollVertical = overScrollMode == 0 || overScrollMode == 1 && canScrollVertical;
+        int newScrollX = scrollX + deltaX;
+        if(!overScrollHorizontal) {
+            maxOverScrollX = 0;
+        }
+
+        int newScrollY = scrollY + deltaY;
+        if(!overScrollVertical) {
+            maxOverScrollY = 0;
+        }
+
+        int left = -maxOverScrollX;
+        int right = maxOverScrollX + scrollRangeX;
+        int top = -maxOverScrollY;
+        int bottom = maxOverScrollY + scrollRangeY;
+        boolean clampedX = false;
+        if(newScrollX > right) {
+            newScrollX = right;
+            clampedX = true;
+        } else if(newScrollX < left) {
+            newScrollX = left;
+            clampedX = true;
+        }
+
+        boolean clampedY = false;
+        if(newScrollY > bottom) {
+            newScrollY = bottom;
+            clampedY = true;
+        } else if(newScrollY < top) {
+            newScrollY = top;
+            clampedY = true;
+        }
+
+        this.onOverScrolled(newScrollX, newScrollY, clampedX, clampedY);
+        return clampedX || clampedY;
+    }
+
+    private int getScrollRange() {
+        int scrollRange = 0;
+        if(this.getChildCount() > 0) {
+            View child = this.getChildAt(0);
+            scrollRange = Math.max(0, child.getHeight() - (this.getHeight() - this.getPaddingBottom() - this.getPaddingTop()));
+        }
+
+        return scrollRange;
+    }
+
+    private View findFocusableViewInBounds(boolean topFocus, int top, int bottom) {
+        //noinspection ResourceType
+        ArrayList focusables = this.getFocusables(2);
+        View focusCandidate = null;
+        boolean foundFullyContainedFocusable = false;
+        int count = focusables.size();
+
+        for(int i = 0; i < count; ++i) {
+            View view = (View)focusables.get(i);
+            int viewTop = view.getTop();
+            int viewBottom = view.getBottom();
+            if(top < viewBottom && viewTop < bottom) {
+                boolean viewIsFullyContained = top < viewTop && viewBottom < bottom;
+                if(focusCandidate == null) {
+                    focusCandidate = view;
+                    foundFullyContainedFocusable = viewIsFullyContained;
+                } else {
+                    boolean viewIsCloserToBoundary = topFocus && viewTop < focusCandidate.getTop() || !topFocus && viewBottom > focusCandidate.getBottom();
+                    if(foundFullyContainedFocusable) {
+                        if(viewIsFullyContained && viewIsCloserToBoundary) {
+                            focusCandidate = view;
+                        }
+                    } else if(viewIsFullyContained) {
+                        focusCandidate = view;
+                        foundFullyContainedFocusable = true;
+                    } else if(viewIsCloserToBoundary) {
+                        focusCandidate = view;
+                    }
+                }
+            }
+        }
+
+        return focusCandidate;
+    }
+
+    public boolean pageScroll(int direction) {
+        boolean down = direction == 130;
+        int height = this.getHeight();
+        if(down) {
+            this.mTempRect.top = this.getScrollY() + height;
+            int count = this.getChildCount();
+            if(count > 0) {
+                View view = this.getChildAt(count - 1);
+                if(this.mTempRect.top + height > view.getBottom()) {
+                    this.mTempRect.top = view.getBottom() - height;
+                }
+            }
+        } else {
+            this.mTempRect.top = this.getScrollY() - height;
+            if(this.mTempRect.top < 0) {
+                this.mTempRect.top = 0;
+            }
+        }
+
+        this.mTempRect.bottom = this.mTempRect.top + height;
+        return this.scrollAndFocus(direction, this.mTempRect.top, this.mTempRect.bottom);
+    }
+
+    public boolean fullScroll(int direction) {
+        boolean down = direction == 130;
+        int height = this.getHeight();
+        this.mTempRect.top = 0;
+        this.mTempRect.bottom = height;
+        if(down) {
+            int count = this.getChildCount();
+            if(count > 0) {
+                View view = this.getChildAt(count - 1);
+                this.mTempRect.bottom = view.getBottom() + this.getPaddingBottom();
+                this.mTempRect.top = this.mTempRect.bottom - height;
+            }
+        }
+
+        return this.scrollAndFocus(direction, this.mTempRect.top, this.mTempRect.bottom);
+    }
+
+    private boolean scrollAndFocus(int direction, int top, int bottom) {
+        boolean handled = true;
+        int height = this.getHeight();
+        int containerTop = this.getScrollY();
+        int containerBottom = containerTop + height;
+        boolean up = direction == 33;
+        Object newFocused = this.findFocusableViewInBounds(up, top, bottom);
+        if(newFocused == null) {
+            newFocused = this;
+        }
+
+        if(top >= containerTop && bottom <= containerBottom) {
+            handled = false;
+        } else {
+            int delta = up?top - containerTop:bottom - containerBottom;
+            this.doScrollY(delta);
+        }
+
+        if(newFocused != this.findFocus()) {
+            ((View)newFocused).requestFocus(direction);
+        }
+
+        return handled;
+    }
+
+    public boolean arrowScroll(int direction) {
+        View currentFocused = this.findFocus();
+        if(currentFocused == this) {
+            currentFocused = null;
+        }
+
+        View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);
+        int maxJump = this.getMaxScrollAmount();
+        int descendantFocusability;
+        if(nextFocused != null && this.isWithinDeltaOfScreen(nextFocused, maxJump, this.getHeight())) {
+            nextFocused.getDrawingRect(this.mTempRect);
+            this.offsetDescendantRectToMyCoords(nextFocused, this.mTempRect);
+            descendantFocusability = this.computeScrollDeltaToGetChildRectOnScreen(this.mTempRect);
+            this.doScrollY(descendantFocusability);
+            nextFocused.requestFocus(direction);
+        } else {
+            descendantFocusability = maxJump;
+            if(direction == 33 && this.getScrollY() < maxJump) {
+                descendantFocusability = this.getScrollY();
+            } else if(direction == 130 && this.getChildCount() > 0) {
+                int daBottom = this.getChildAt(0).getBottom();
+                int screenBottom = this.getScrollY() + this.getHeight() - this.getPaddingBottom();
+                if(daBottom - screenBottom < maxJump) {
+                    descendantFocusability = daBottom - screenBottom;
+                }
+            }
+
+            if(descendantFocusability == 0) {
+                return false;
+            }
+
+            this.doScrollY(direction == 130?descendantFocusability:-descendantFocusability);
+        }
+
+        if(currentFocused != null && currentFocused.isFocused() && this.isOffScreen(currentFocused)) {
+            descendantFocusability = this.getDescendantFocusability();
+            //noinspection ResourceType
+            this.setDescendantFocusability(131072);
+            this.requestFocus();
+            this.setDescendantFocusability(descendantFocusability);
+        }
+
+        return true;
+    }
+
+    private boolean isOffScreen(View descendant) {
+        return !this.isWithinDeltaOfScreen(descendant, 0, this.getHeight());
+    }
+
+    private boolean isWithinDeltaOfScreen(View descendant, int delta, int height) {
+        descendant.getDrawingRect(this.mTempRect);
+        this.offsetDescendantRectToMyCoords(descendant, this.mTempRect);
+        return this.mTempRect.bottom + delta >= this.getScrollY() && this.mTempRect.top - delta <= this.getScrollY() + height;
+    }
+
+    private void doScrollY(int delta) {
+        if(delta != 0) {
+            if(this.mSmoothScrollingEnabled) {
+                this.smoothScrollBy(0, delta);
+            } else {
+                this.scrollBy(0, delta);
+            }
+        }
+
+    }
+
+    public final void smoothScrollBy(int dx, int dy) {
+        if(this.getChildCount() != 0) {
+            long duration = AnimationUtils.currentAnimationTimeMillis() - this.mLastScroll;
+            if(duration > 250L) {
+                int height = this.getHeight() - this.getPaddingBottom() - this.getPaddingTop();
+                int bottom = this.getChildAt(0).getHeight();
+                int maxY = Math.max(0, bottom - height);
+                int scrollY = this.getScrollY();
+                dy = Math.max(0, Math.min(scrollY + dy, maxY)) - scrollY;
+                this.mScroller.startScroll(this.getScrollX(), scrollY, 0, dy);
+                ViewCompat.postInvalidateOnAnimation(this);
+            } else {
+                if(!this.mScroller.isFinished()) {
+                    this.mScroller.abortAnimation();
+                }
+
+                this.scrollBy(dx, dy);
+            }
+
+            this.mLastScroll = AnimationUtils.currentAnimationTimeMillis();
+        }
+    }
+
+    public final void smoothScrollTo(int x, int y) {
+        this.smoothScrollBy(x - this.getScrollX(), y - this.getScrollY());
+    }
+
+    protected int computeVerticalScrollRange() {
+        int count = this.getChildCount();
+        int contentHeight = this.getHeight() - this.getPaddingBottom() - this.getPaddingTop();
+        if(count == 0) {
+            return contentHeight;
+        } else {
+            int scrollRange = this.getChildAt(0).getBottom();
+            int scrollY = this.getScrollY();
+            int overscrollBottom = Math.max(0, scrollRange - contentHeight);
+            if(scrollY < 0) {
+                scrollRange -= scrollY;
+            } else if(scrollY > overscrollBottom) {
+                scrollRange += scrollY - overscrollBottom;
+            }
+
+            return scrollRange;
+        }
+    }
+
+    protected int computeVerticalScrollOffset() {
+        return Math.max(0, super.computeVerticalScrollOffset());
+    }
+
+    protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec) {
+        LayoutParams lp = (LayoutParams) child.getLayoutParams();
+        int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, this.getPaddingLeft() + this.getPaddingRight(), lp.width);
+        //noinspection ResourceType
+        int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(0, 0);
+        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+    }
+
+    protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed) {
+        MarginLayoutParams lp = (MarginLayoutParams)child.getLayoutParams();
+        int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, this.getPaddingLeft() + this.getPaddingRight() + lp.leftMargin + lp.rightMargin + widthUsed, lp.width);
+        //noinspection ResourceType
+        int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(lp.topMargin + lp.bottomMargin, 0);
+        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+    }
+
+    public void computeScroll() {
+        if(this.mScroller.computeScrollOffset()) {
+            int oldX = this.getScrollX();
+            int oldY = this.getScrollY();
+            int x = this.mScroller.getCurrX();
+            int y = this.mScroller.getCurrY();
+            if(oldX != x || oldY != y) {
+                int range = this.getScrollRange();
+                int overscrollMode = ViewCompat.getOverScrollMode(this);
+                boolean canOverscroll = overscrollMode == 0 || overscrollMode == 1 && range > 0;
+                this.overScrollByCompat(x - oldX, y - oldY, oldX, oldY, 0, range, 0, 0, false);
+                if(canOverscroll) {
+                    this.ensureGlows();
+                    if(y <= 0 && oldY > 0) {
+                        this.mEdgeGlowTop.onAbsorb((int)this.mScroller.getCurrVelocity());
+                    } else if(y >= range && oldY < range) {
+                        this.mEdgeGlowBottom.onAbsorb((int)this.mScroller.getCurrVelocity());
+                    }
+                }
+            }
+        }
+
+    }
+
+    private void scrollToChild(View child) {
+        child.getDrawingRect(this.mTempRect);
+        this.offsetDescendantRectToMyCoords(child, this.mTempRect);
+        int scrollDelta = this.computeScrollDeltaToGetChildRectOnScreen(this.mTempRect);
+        if(scrollDelta != 0) {
+            this.scrollBy(0, scrollDelta);
+        }
+
+    }
+
+    private boolean scrollToChildRect(Rect rect, boolean immediate) {
+        int delta = this.computeScrollDeltaToGetChildRectOnScreen(rect);
+        boolean scroll = delta != 0;
+        if(scroll) {
+            if(immediate) {
+                this.scrollBy(0, delta);
+            } else {
+                this.smoothScrollBy(0, delta);
+            }
+        }
+
+        return scroll;
+    }
+
+    protected int computeScrollDeltaToGetChildRectOnScreen(Rect rect) {
+        if(this.getChildCount() == 0) {
+            return 0;
+        } else {
+            int height = this.getHeight();
+            int screenTop = this.getScrollY();
+            int screenBottom = screenTop + height;
+            int fadingEdge = this.getVerticalFadingEdgeLength();
+            if(rect.top > 0) {
+                screenTop += fadingEdge;
+            }
+
+            if(rect.bottom < this.getChildAt(0).getHeight()) {
+                screenBottom -= fadingEdge;
+            }
+
+            int scrollYDelta = 0;
+            if(rect.bottom > screenBottom && rect.top > screenTop) {
+                if(rect.height() > height) {
+                    scrollYDelta += rect.top - screenTop;
+                } else {
+                    scrollYDelta += rect.bottom - screenBottom;
+                }
+
+                int bottom = this.getChildAt(0).getBottom();
+                int distanceToBottom = bottom - screenBottom;
+                scrollYDelta = Math.min(scrollYDelta, distanceToBottom);
+            } else if(rect.top < screenTop && rect.bottom < screenBottom) {
+                if(rect.height() > height) {
+                    scrollYDelta -= screenBottom - rect.bottom;
+                } else {
+                    scrollYDelta -= screenTop - rect.top;
+                }
+
+                scrollYDelta = Math.max(scrollYDelta, -this.getScrollY());
+            }
+
+            return scrollYDelta;
+        }
+    }
+
+    public void requestChildFocus(View child, View focused) {
+        if(!this.mIsLayoutDirty) {
+            this.scrollToChild(focused);
+        } else {
+            this.mChildToScrollTo = focused;
+        }
+
+        super.requestChildFocus(child, focused);
+    }
+
+    protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
+        if(direction == 2) {
+            direction = 130;
+        } else if(direction == 1) {
+            direction = 33;
+        }
+
+        View nextFocus = previouslyFocusedRect == null?FocusFinder.getInstance().findNextFocus(this, (View)null, direction):FocusFinder.getInstance().findNextFocusFromRect(this, previouslyFocusedRect, direction);
+        return nextFocus == null?false:(this.isOffScreen(nextFocus)?false:nextFocus.requestFocus(direction, previouslyFocusedRect));
+    }
+
+    public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
+        rectangle.offset(child.getLeft() - child.getScrollX(), child.getTop() - child.getScrollY());
+        return this.scrollToChildRect(rectangle, immediate);
+    }
+
+    public void requestLayout() {
+        this.mIsLayoutDirty = true;
+        super.requestLayout();
+    }
+
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        super.onLayout(changed, l, t, r, b);
+        this.mIsLayoutDirty = false;
+        if(this.mChildToScrollTo != null && isViewDescendantOf(this.mChildToScrollTo, this)) {
+            this.scrollToChild(this.mChildToScrollTo);
+        }
+
+        this.mChildToScrollTo = null;
+        if(!this.mIsLaidOut) {
+            if(this.mSavedState != null) {
+                this.scrollTo(this.getScrollX(), this.mSavedState.scrollPosition);
+                this.mSavedState = null;
+            }
+
+            int childHeight = this.getChildCount() > 0?this.getChildAt(0).getMeasuredHeight():0;
+            int scrollRange = Math.max(0, childHeight - (b - t - this.getPaddingBottom() - this.getPaddingTop()));
+            if(this.getScrollY() > scrollRange) {
+                this.scrollTo(this.getScrollX(), scrollRange);
+            } else if(this.getScrollY() < 0) {
+                this.scrollTo(this.getScrollX(), 0);
+            }
+        }
+
+        this.scrollTo(this.getScrollX(), this.getScrollY());
+        this.mIsLaidOut = true;
+    }
+
+    @SuppressLint("MissingSuperCall")
+    public void onAttachedToWindow() {
+        this.mIsLaidOut = false;
+    }
+
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        View currentFocused = this.findFocus();
+        if(null != currentFocused && this != currentFocused) {
+            if(this.isWithinDeltaOfScreen(currentFocused, 0, oldh)) {
+                currentFocused.getDrawingRect(this.mTempRect);
+                this.offsetDescendantRectToMyCoords(currentFocused, this.mTempRect);
+                int scrollDelta = this.computeScrollDeltaToGetChildRectOnScreen(this.mTempRect);
+                this.doScrollY(scrollDelta);
+            }
+
+        }
+    }
+
+    private static boolean isViewDescendantOf(View child, View parent) {
+        if(child == parent) {
+            return true;
+        } else {
+            ViewParent theParent = child.getParent();
+            return theParent instanceof ViewGroup && isViewDescendantOf((View)theParent, parent);
+        }
+    }
+
+    /**
+     * Adjusted from AppCompat v23.0.0 so that the function returns true if the nested fling will
+     * end at the top of the scroll view. Which means that it should be dispatched to the
+     * CoordinatorLayout/AppBarLayout
+     * @param velocityY
+     * @return
+     */
+    public boolean fling(int velocityY) {
+        if(this.getChildCount() > 0) {
+            int height = this.getHeight() - this.getPaddingBottom() - this.getPaddingTop();
+            int bottom = this.getChildAt(0).getHeight();
+            this.mScroller.fling(this.getScrollX(), this.getScrollY(), 0, velocityY, 0, 0, 0, Math.max(0, bottom - height), 0, height / 2);
+            ViewCompat.postInvalidateOnAnimation(this);
+            return mScroller.getFinalY() == 0;
+        }
+        return false;
+    }
+
+    private void flingWithNestedDispatch(int velocityY) {
+        int scrollY = this.getScrollY();
+        boolean canFling = (scrollY > 0 || velocityY > 0) && (scrollY < this.getScrollRange() || velocityY < 0);
+        if(!this.dispatchNestedPreFling(0.0F, (float)velocityY)) {
+            boolean dispatchFling = true;
+            if (canFling)
+                dispatchFling = fling(velocityY);
+            this.dispatchNestedFling(0.0F, (float)velocityY, !dispatchFling);
+        }
+
+    }
+
+    private void endDrag() {
+        this.mIsBeingDragged = false;
+        this.recycleVelocityTracker();
+        this.stopNestedScroll();
+        if(this.mEdgeGlowTop != null) {
+            this.mEdgeGlowTop.onRelease();
+            this.mEdgeGlowBottom.onRelease();
+        }
+
+    }
+
+    public void scrollTo(int x, int y) {
+        if(this.getChildCount() > 0) {
+            View child = this.getChildAt(0);
+            x = clamp(x, this.getWidth() - this.getPaddingRight() - this.getPaddingLeft(), child.getWidth());
+            y = clamp(y, this.getHeight() - this.getPaddingBottom() - this.getPaddingTop(), child.getHeight());
+            if(x != this.getScrollX() || y != this.getScrollY()) {
+                super.scrollTo(x, y);
+            }
+        }
+
+    }
+
+    private void ensureGlows() {
+        if(ViewCompat.getOverScrollMode(this) != 2) {
+            if(this.mEdgeGlowTop == null) {
+                Context context = this.getContext();
+                this.mEdgeGlowTop = new EdgeEffectCompat(context);
+                this.mEdgeGlowBottom = new EdgeEffectCompat(context);
+            }
+        } else {
+            this.mEdgeGlowTop = null;
+            this.mEdgeGlowBottom = null;
+        }
+
+    }
+
+    public void draw(Canvas canvas) {
+        super.draw(canvas);
+        if(this.mEdgeGlowTop != null) {
+            int scrollY = this.getScrollY();
+            int restoreCount;
+            int width;
+            if(!this.mEdgeGlowTop.isFinished()) {
+                restoreCount = canvas.save();
+                width = this.getWidth() - this.getPaddingLeft() - this.getPaddingRight();
+                canvas.translate((float)this.getPaddingLeft(), (float)Math.min(0, scrollY));
+                this.mEdgeGlowTop.setSize(width, this.getHeight());
+                if(this.mEdgeGlowTop.draw(canvas)) {
+                    ViewCompat.postInvalidateOnAnimation(this);
+                }
+
+                canvas.restoreToCount(restoreCount);
+            }
+
+            if(!this.mEdgeGlowBottom.isFinished()) {
+                restoreCount = canvas.save();
+                width = this.getWidth() - this.getPaddingLeft() - this.getPaddingRight();
+                int height = this.getHeight();
+                canvas.translate((float)(-width + this.getPaddingLeft()), (float)(Math.max(this.getScrollRange(), scrollY) + height));
+                canvas.rotate(180.0F, (float)width, 0.0F);
+                this.mEdgeGlowBottom.setSize(width, height);
+                if(this.mEdgeGlowBottom.draw(canvas)) {
+                    ViewCompat.postInvalidateOnAnimation(this);
+                }
+
+                canvas.restoreToCount(restoreCount);
+            }
+        }
+
+    }
+
+    private static int clamp(int n, int my, int child) {
+        return my < child && n >= 0?(my + n > child?child - my:n):0;
+    }
+
+    protected void onRestoreInstanceState(Parcelable state) {
+        FlingNestedScrollView.SavedState ss = (FlingNestedScrollView.SavedState)state;
+        super.onRestoreInstanceState(ss.getSuperState());
+        this.mSavedState = ss;
+        this.requestLayout();
+    }
+
+    protected Parcelable onSaveInstanceState() {
+        Parcelable superState = super.onSaveInstanceState();
+        FlingNestedScrollView.SavedState ss = new FlingNestedScrollView.SavedState(superState);
+        ss.scrollPosition = this.getScrollY();
+        return ss;
+    }
+
+    static class AccessibilityDelegate extends AccessibilityDelegateCompat {
+        AccessibilityDelegate() {
+        }
+
+        public boolean performAccessibilityAction(View host, int action, Bundle arguments) {
+            if(super.performAccessibilityAction(host, action, arguments)) {
+                return true;
+            } else {
+                FlingNestedScrollView nsvHost = (FlingNestedScrollView)host;
+                if(!nsvHost.isEnabled()) {
+                    return false;
+                } else {
+                    int viewportHeight;
+                    int targetScrollY;
+                    switch(action) {
+                        case 4096:
+                            viewportHeight = nsvHost.getHeight() - nsvHost.getPaddingBottom() - nsvHost.getPaddingTop();
+                            targetScrollY = Math.min(nsvHost.getScrollY() + viewportHeight, nsvHost.getScrollRange());
+                            if(targetScrollY != nsvHost.getScrollY()) {
+                                nsvHost.smoothScrollTo(0, targetScrollY);
+                                return true;
+                            }
+
+                            return false;
+                        case 8192:
+                            viewportHeight = nsvHost.getHeight() - nsvHost.getPaddingBottom() - nsvHost.getPaddingTop();
+                            targetScrollY = Math.max(nsvHost.getScrollY() - viewportHeight, 0);
+                            if(targetScrollY != nsvHost.getScrollY()) {
+                                nsvHost.smoothScrollTo(0, targetScrollY);
+                                return true;
+                            }
+
+                            return false;
+                        default:
+                            return false;
+                    }
+                }
+            }
+        }
+
+        public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
+            super.onInitializeAccessibilityNodeInfo(host, info);
+            FlingNestedScrollView nsvHost = (FlingNestedScrollView)host;
+            info.setClassName(ScrollView.class.getName());
+            if(nsvHost.isEnabled()) {
+                int scrollRange = nsvHost.getScrollRange();
+                if(scrollRange > 0) {
+                    info.setScrollable(true);
+                    if(nsvHost.getScrollY() > 0) {
+                        info.addAction(8192);
+                    }
+
+                    if(nsvHost.getScrollY() < scrollRange) {
+                        info.addAction(4096);
+                    }
+                }
+            }
+
+        }
+
+        public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
+            super.onInitializeAccessibilityEvent(host, event);
+            FlingNestedScrollView nsvHost = (FlingNestedScrollView)host;
+            event.setClassName(ScrollView.class.getName());
+            AccessibilityRecordCompat record = AccessibilityEventCompat.asRecord(event);
+            boolean scrollable = nsvHost.getScrollRange() > 0;
+            record.setScrollable(scrollable);
+            record.setScrollX(nsvHost.getScrollX());
+            record.setScrollY(nsvHost.getScrollY());
+            record.setMaxScrollX(nsvHost.getScrollX());
+            record.setMaxScrollY(nsvHost.getScrollRange());
+        }
+    }
+
+    static class SavedState extends BaseSavedState {
+        public int scrollPosition;
+        public static final Creator<FlingNestedScrollView.SavedState> CREATOR = new Creator() {
+            public FlingNestedScrollView.SavedState createFromParcel(Parcel in) {
+                return new FlingNestedScrollView.SavedState(in);
+            }
+
+            public FlingNestedScrollView.SavedState[] newArray(int size) {
+                return new FlingNestedScrollView.SavedState[size];
+            }
+        };
+
+        SavedState(Parcelable superState) {
+            super(superState);
+        }
+
+        public SavedState(Parcel source) {
+            super(source);
+            this.scrollPosition = source.readInt();
+        }
+
+        public void writeToParcel(Parcel dest, int flags) {
+            super.writeToParcel(dest, flags);
+            dest.writeInt(this.scrollPosition);
+        }
+
+        public String toString() {
+            return "HorizontalScrollView.SavedState{" + Integer.toHexString(System.identityHashCode(this)) + " scrollPosition=" + this.scrollPosition + "}";
+        }
+    }
+}