aboutsummaryrefslogtreecommitdiffstats
path: root/OpenKeychain/src/main/java/android
diff options
context:
space:
mode:
Diffstat (limited to 'OpenKeychain/src/main/java/android')
-rw-r--r--OpenKeychain/src/main/java/android/support/v4/widget/FlingNestedScrollView.java1355
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 + "}";
+ }
+ }
+}