| /* |
| * Copyright (C) 2012 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 com.android.keyguard; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.AnimatorSet; |
| import android.animation.ObjectAnimator; |
| import android.animation.TimeInterpolator; |
| import android.animation.ValueAnimator; |
| import android.animation.ValueAnimator.AnimatorUpdateListener; |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.content.res.TypedArray; |
| import android.graphics.Canvas; |
| import android.graphics.Matrix; |
| import android.graphics.PointF; |
| import android.graphics.Rect; |
| import android.os.Bundle; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.util.AttributeSet; |
| import android.util.DisplayMetrics; |
| import android.util.Log; |
| import android.view.InputDevice; |
| 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.ViewPropertyAnimator; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.view.accessibility.AccessibilityManager; |
| import android.view.accessibility.AccessibilityNodeInfo; |
| import android.view.animation.AccelerateInterpolator; |
| import android.view.animation.AnimationUtils; |
| import android.view.animation.DecelerateInterpolator; |
| import android.view.animation.Interpolator; |
| import android.view.animation.LinearInterpolator; |
| import android.widget.Scroller; |
| |
| import java.util.ArrayList; |
| |
| /** |
| * An abstraction of the original Workspace which supports browsing through a |
| * sequential list of "pages" |
| */ |
| public abstract class PagedView extends ViewGroup implements ViewGroup.OnHierarchyChangeListener { |
| private static final int WARP_SNAP_DURATION = 160; |
| private static final String TAG = "WidgetPagedView"; |
| private static final boolean DEBUG = false; |
| private static final boolean DEBUG_WARP = false; |
| protected static final int INVALID_PAGE = -1; |
| private static final int WARP_PEEK_ANIMATION_DURATION = 150; |
| private static final float WARP_ANIMATE_AMOUNT = -75.0f; // in dip |
| |
| // the min drag distance for a fling to register, to prevent random page shifts |
| private static final int MIN_LENGTH_FOR_FLING = 25; |
| |
| protected static final int PAGE_SNAP_ANIMATION_DURATION = 750; |
| protected static final int SLOW_PAGE_SNAP_ANIMATION_DURATION = 950; |
| protected static final float NANOTIME_DIV = 1000000000.0f; |
| |
| private static final float OVERSCROLL_ACCELERATE_FACTOR = 2; |
| private static final float OVERSCROLL_DAMP_FACTOR = 0.14f; |
| |
| private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.33f; |
| // The page is moved more than halfway, automatically move to the next page on touch up. |
| private static final float SIGNIFICANT_MOVE_THRESHOLD = 0.5f; |
| |
| // The following constants need to be scaled based on density. The scaled versions will be |
| // assigned to the corresponding member variables below. |
| private static final int FLING_THRESHOLD_VELOCITY = 1500; |
| private static final int MIN_SNAP_VELOCITY = 1500; |
| private static final int MIN_FLING_VELOCITY = 500; |
| |
| // We are disabling touch interaction of the widget region for factory ROM. |
| private static final boolean DISABLE_TOUCH_INTERACTION = false; |
| private static final boolean DISABLE_TOUCH_SIDE_PAGES = true; |
| private static final boolean DISABLE_FLING_TO_DELETE = false; |
| |
| static final int AUTOMATIC_PAGE_SPACING = -1; |
| |
| protected int mFlingThresholdVelocity; |
| protected int mMinFlingVelocity; |
| protected int mMinSnapVelocity; |
| |
| protected float mDensity; |
| protected float mSmoothingTime; |
| protected float mTouchX; |
| |
| protected boolean mFirstLayout = true; |
| |
| protected int mCurrentPage; |
| protected int mChildCountOnLastMeasure; |
| |
| protected int mNextPage = INVALID_PAGE; |
| protected int mMaxScrollX; |
| protected Scroller mScroller; |
| private VelocityTracker mVelocityTracker; |
| |
| private float mParentDownMotionX; |
| private float mParentDownMotionY; |
| private float mDownMotionX; |
| private float mDownMotionY; |
| private float mDownScrollX; |
| protected float mLastMotionX; |
| protected float mLastMotionXRemainder; |
| protected float mLastMotionY; |
| protected float mTotalMotionX; |
| private int mLastScreenCenter = -1; |
| private int[] mChildOffsets; |
| private int[] mChildRelativeOffsets; |
| private int[] mChildOffsetsWithLayoutScale; |
| private String mDeleteString; // Accessibility announcement when widget is deleted |
| |
| protected final static int TOUCH_STATE_REST = 0; |
| protected final static int TOUCH_STATE_SCROLLING = 1; |
| protected final static int TOUCH_STATE_PREV_PAGE = 2; |
| protected final static int TOUCH_STATE_NEXT_PAGE = 3; |
| protected final static int TOUCH_STATE_REORDERING = 4; |
| protected final static int TOUCH_STATE_READY = 5; // when finger is down |
| |
| protected final static float ALPHA_QUANTIZE_LEVEL = 0.0001f; |
| protected final static float TOUCH_SLOP_SCALE = 1.0f; |
| |
| protected int mTouchState = TOUCH_STATE_REST; |
| protected boolean mForceScreenScrolled = false; |
| |
| protected OnLongClickListener mLongClickListener; |
| |
| protected int mTouchSlop; |
| private int mPagingTouchSlop; |
| private int mMaximumVelocity; |
| private int mMinimumWidth; |
| protected int mPageSpacing; |
| protected int mCellCountX = 0; |
| protected int mCellCountY = 0; |
| protected boolean mAllowOverScroll = true; |
| protected int mUnboundedScrollX; |
| protected int[] mTempVisiblePagesRange = new int[2]; |
| protected boolean mForceDrawAllChildrenNextFrame; |
| |
| // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. Otherwise |
| // it is equal to the scaled overscroll position. We use a separate value so as to prevent |
| // the screens from continuing to translate beyond the normal bounds. |
| protected int mOverScrollX; |
| |
| // parameter that adjusts the layout to be optimized for pages with that scale factor |
| protected float mLayoutScale = 1.0f; |
| |
| protected static final int INVALID_POINTER = -1; |
| |
| protected int mActivePointerId = INVALID_POINTER; |
| |
| private PageSwitchListener mPageSwitchListener; |
| |
| protected ArrayList<Boolean> mDirtyPageContent; |
| |
| // If true, syncPages and syncPageItems will be called to refresh pages |
| protected boolean mContentIsRefreshable = true; |
| |
| // If true, modify alpha of neighboring pages as user scrolls left/right |
| protected boolean mFadeInAdjacentScreens = false; |
| |
| // It true, use a different slop parameter (pagingTouchSlop = 2 * touchSlop) for deciding |
| // to switch to a new page |
| protected boolean mUsePagingTouchSlop = true; |
| |
| // If true, the subclass should directly update scrollX itself in its computeScroll method |
| // (SmoothPagedView does this) |
| protected boolean mDeferScrollUpdate = false; |
| |
| protected boolean mIsPageMoving = false; |
| |
| // All syncs and layout passes are deferred until data is ready. |
| protected boolean mIsDataReady = true; |
| |
| // Scrolling indicator |
| private ValueAnimator mScrollIndicatorAnimator; |
| private View mScrollIndicator; |
| private int mScrollIndicatorPaddingLeft; |
| private int mScrollIndicatorPaddingRight; |
| private boolean mShouldShowScrollIndicator = false; |
| private boolean mShouldShowScrollIndicatorImmediately = false; |
| protected static final int sScrollIndicatorFadeInDuration = 150; |
| protected static final int sScrollIndicatorFadeOutDuration = 650; |
| protected static final int sScrollIndicatorFlashDuration = 650; |
| |
| // The viewport whether the pages are to be contained (the actual view may be larger than the |
| // viewport) |
| private Rect mViewport = new Rect(); |
| |
| // Reordering |
| // We use the min scale to determine how much to expand the actually PagedView measured |
| // dimensions such that when we are zoomed out, the view is not clipped |
| private int REORDERING_DROP_REPOSITION_DURATION = 200; |
| protected int REORDERING_REORDER_REPOSITION_DURATION = 300; |
| protected int REORDERING_ZOOM_IN_OUT_DURATION = 250; |
| private int REORDERING_SIDE_PAGE_HOVER_TIMEOUT = 300; |
| private float REORDERING_SIDE_PAGE_BUFFER_PERCENTAGE = 0.1f; |
| private long REORDERING_DELETE_DROP_TARGET_FADE_DURATION = 150; |
| private float mMinScale = 1f; |
| protected View mDragView; |
| protected AnimatorSet mZoomInOutAnim; |
| private Runnable mSidePageHoverRunnable; |
| private int mSidePageHoverIndex = -1; |
| // This variable's scope is only for the duration of startReordering() and endReordering() |
| private boolean mReorderingStarted = false; |
| // This variable's scope is for the duration of startReordering() and after the zoomIn() |
| // animation after endReordering() |
| private boolean mIsReordering; |
| // The runnable that settles the page after snapToPage and animateDragViewToOriginalPosition |
| private int NUM_ANIMATIONS_RUNNING_BEFORE_ZOOM_OUT = 2; |
| private int mPostReorderingPreZoomInRemainingAnimationCount; |
| private Runnable mPostReorderingPreZoomInRunnable; |
| |
| // Edge swiping |
| private boolean mOnlyAllowEdgeSwipes = false; |
| private boolean mDownEventOnEdge = false; |
| private int mEdgeSwipeRegionSize = 0; |
| |
| // Convenience/caching |
| private Matrix mTmpInvMatrix = new Matrix(); |
| private float[] mTmpPoint = new float[2]; |
| private Rect mTmpRect = new Rect(); |
| private Rect mAltTmpRect = new Rect(); |
| |
| // Fling to delete |
| private int FLING_TO_DELETE_FADE_OUT_DURATION = 350; |
| private float FLING_TO_DELETE_FRICTION = 0.035f; |
| // The degrees specifies how much deviation from the up vector to still consider a fling "up" |
| private float FLING_TO_DELETE_MAX_FLING_DEGREES = 65f; |
| protected int mFlingToDeleteThresholdVelocity = -1400; |
| // Drag to delete |
| private boolean mDeferringForDelete = false; |
| private int DELETE_SLIDE_IN_SIDE_PAGE_DURATION = 250; |
| private int DRAG_TO_DELETE_FADE_OUT_DURATION = 350; |
| |
| // Drop to delete |
| private View mDeleteDropTarget; |
| |
| // Bouncer |
| private boolean mTopAlignPageWhenShrinkingForBouncer = false; |
| |
| // Page warping |
| private int mPageSwapIndex = -1; // the page we swapped out if needed |
| private int mPageWarpIndex = -1; // the page we intend to warp |
| private boolean mWarpPageExposed; |
| private ViewPropertyAnimator mWarpAnimation; |
| |
| private boolean mIsCameraEvent; |
| private float mWarpPeekAmount; |
| private boolean mOnPageEndWarpCalled; |
| private boolean mOnPageBeginWarpCalled; |
| |
| public interface PageSwitchListener { |
| void onPageSwitching(View newPage, int newPageIndex); |
| void onPageSwitched(View newPage, int newPageIndex); |
| } |
| |
| public PagedView(Context context) { |
| this(context, null); |
| } |
| |
| public PagedView(Context context, AttributeSet attrs) { |
| this(context, attrs, 0); |
| } |
| |
| public PagedView(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| TypedArray a = context.obtainStyledAttributes(attrs, |
| R.styleable.PagedView, defStyle, 0); |
| setPageSpacing(a.getDimensionPixelSize(R.styleable.PagedView_pageSpacing, 0)); |
| mScrollIndicatorPaddingLeft = |
| a.getDimensionPixelSize(R.styleable.PagedView_scrollIndicatorPaddingLeft, 0); |
| mScrollIndicatorPaddingRight = |
| a.getDimensionPixelSize(R.styleable.PagedView_scrollIndicatorPaddingRight, 0); |
| a.recycle(); |
| |
| Resources r = getResources(); |
| mEdgeSwipeRegionSize = r.getDimensionPixelSize(R.dimen.kg_edge_swipe_region_size); |
| mTopAlignPageWhenShrinkingForBouncer = |
| r.getBoolean(R.bool.kg_top_align_page_shrink_on_bouncer_visible); |
| |
| setHapticFeedbackEnabled(false); |
| init(); |
| } |
| |
| /** |
| * Initializes various states for this workspace. |
| */ |
| protected void init() { |
| mDirtyPageContent = new ArrayList<Boolean>(); |
| mDirtyPageContent.ensureCapacity(32); |
| mScroller = new Scroller(getContext(), new ScrollInterpolator()); |
| mCurrentPage = 0; |
| |
| final ViewConfiguration configuration = ViewConfiguration.get(getContext()); |
| mTouchSlop = configuration.getScaledTouchSlop(); |
| mPagingTouchSlop = configuration.getScaledPagingTouchSlop(); |
| mMaximumVelocity = configuration.getScaledMaximumFlingVelocity(); |
| mDensity = getResources().getDisplayMetrics().density; |
| mWarpPeekAmount = mDensity * WARP_ANIMATE_AMOUNT; |
| |
| // Scale the fling-to-delete threshold by the density |
| mFlingToDeleteThresholdVelocity = (int) (mFlingToDeleteThresholdVelocity * mDensity); |
| |
| mFlingThresholdVelocity = (int) (FLING_THRESHOLD_VELOCITY * mDensity); |
| mMinFlingVelocity = (int) (MIN_FLING_VELOCITY * mDensity); |
| mMinSnapVelocity = (int) (MIN_SNAP_VELOCITY * mDensity); |
| setOnHierarchyChangeListener(this); |
| } |
| |
| void setDeleteDropTarget(View v) { |
| mDeleteDropTarget = v; |
| } |
| |
| // Convenience methods to map points from self to parent and vice versa |
| float[] mapPointFromViewToParent(View v, float x, float y) { |
| mTmpPoint[0] = x; |
| mTmpPoint[1] = y; |
| v.getMatrix().mapPoints(mTmpPoint); |
| mTmpPoint[0] += v.getLeft(); |
| mTmpPoint[1] += v.getTop(); |
| return mTmpPoint; |
| } |
| float[] mapPointFromParentToView(View v, float x, float y) { |
| mTmpPoint[0] = x - v.getLeft(); |
| mTmpPoint[1] = y - v.getTop(); |
| v.getMatrix().invert(mTmpInvMatrix); |
| mTmpInvMatrix.mapPoints(mTmpPoint); |
| return mTmpPoint; |
| } |
| |
| void updateDragViewTranslationDuringDrag() { |
| float x = mLastMotionX - mDownMotionX + getScrollX() - mDownScrollX; |
| float y = mLastMotionY - mDownMotionY; |
| mDragView.setTranslationX(x); |
| mDragView.setTranslationY(y); |
| |
| if (DEBUG) Log.d(TAG, "PagedView.updateDragViewTranslationDuringDrag(): " + x + ", " + y); |
| } |
| |
| public void setMinScale(float f) { |
| mMinScale = f; |
| requestLayout(); |
| } |
| |
| @Override |
| public void setScaleX(float scaleX) { |
| super.setScaleX(scaleX); |
| if (isReordering(true)) { |
| float[] p = mapPointFromParentToView(this, mParentDownMotionX, mParentDownMotionY); |
| mLastMotionX = p[0]; |
| mLastMotionY = p[1]; |
| updateDragViewTranslationDuringDrag(); |
| } |
| } |
| |
| // Convenience methods to get the actual width/height of the PagedView (since it is measured |
| // to be larger to account for the minimum possible scale) |
| int getViewportWidth() { |
| return mViewport.width(); |
| } |
| int getViewportHeight() { |
| return mViewport.height(); |
| } |
| |
| // Convenience methods to get the offset ASSUMING that we are centering the pages in the |
| // PagedView both horizontally and vertically |
| int getViewportOffsetX() { |
| return (getMeasuredWidth() - getViewportWidth()) / 2; |
| } |
| int getViewportOffsetY() { |
| return (getMeasuredHeight() - getViewportHeight()) / 2; |
| } |
| |
| public void setPageSwitchListener(PageSwitchListener pageSwitchListener) { |
| mPageSwitchListener = pageSwitchListener; |
| if (mPageSwitchListener != null) { |
| mPageSwitchListener.onPageSwitched(getPageAt(mCurrentPage), mCurrentPage); |
| } |
| } |
| |
| /** |
| * Called by subclasses to mark that data is ready, and that we can begin loading and laying |
| * out pages. |
| */ |
| protected void setDataIsReady() { |
| mIsDataReady = true; |
| } |
| |
| protected boolean isDataReady() { |
| return mIsDataReady; |
| } |
| |
| /** |
| * Returns the index of the currently displayed page. |
| * |
| * @return The index of the currently displayed page. |
| */ |
| int getCurrentPage() { |
| return mCurrentPage; |
| } |
| |
| int getNextPage() { |
| return (mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage; |
| } |
| |
| int getPageCount() { |
| return getChildCount(); |
| } |
| |
| View getPageAt(int index) { |
| return getChildAt(index); |
| } |
| |
| protected int indexToPage(int index) { |
| return index; |
| } |
| |
| /** |
| * Updates the scroll of the current page immediately to its final scroll position. We use this |
| * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of |
| * the previous tab page. |
| */ |
| protected void updateCurrentPageScroll() { |
| int offset = getChildOffset(mCurrentPage); |
| int relOffset = getRelativeChildOffset(mCurrentPage); |
| int newX = offset - relOffset; |
| scrollTo(newX, 0); |
| mScroller.setFinalX(newX); |
| mScroller.forceFinished(true); |
| } |
| |
| /** |
| * Sets the current page. |
| */ |
| void setCurrentPage(int currentPage) { |
| notifyPageSwitching(currentPage); |
| if (!mScroller.isFinished()) { |
| mScroller.abortAnimation(); |
| } |
| // don't introduce any checks like mCurrentPage == currentPage here-- if we change the |
| // the default |
| if (getChildCount() == 0) { |
| return; |
| } |
| |
| mForceScreenScrolled = true; |
| mCurrentPage = Math.max(0, Math.min(currentPage, getPageCount() - 1)); |
| updateCurrentPageScroll(); |
| updateScrollingIndicator(); |
| notifyPageSwitched(); |
| invalidate(); |
| } |
| |
| public void setOnlyAllowEdgeSwipes(boolean enable) { |
| mOnlyAllowEdgeSwipes = enable; |
| } |
| |
| protected void notifyPageSwitching(int whichPage) { |
| if (mPageSwitchListener != null) { |
| mPageSwitchListener.onPageSwitching(getPageAt(whichPage), whichPage); |
| } |
| } |
| |
| protected void notifyPageSwitched() { |
| if (mPageSwitchListener != null) { |
| mPageSwitchListener.onPageSwitched(getPageAt(mCurrentPage), mCurrentPage); |
| } |
| } |
| |
| protected void pageBeginMoving() { |
| if (DEBUG_WARP) Log.v(TAG, "pageBeginMoving(" + mIsPageMoving + ")"); |
| if (!mIsPageMoving) { |
| mIsPageMoving = true; |
| if (isWarping()) { |
| dispatchOnPageBeginWarp(); |
| if (mPageSwapIndex != -1) { |
| swapPages(mPageSwapIndex, mPageWarpIndex); |
| } |
| } |
| onPageBeginMoving(); |
| } |
| } |
| |
| private void dispatchOnPageBeginWarp() { |
| if (!mOnPageBeginWarpCalled) { |
| onPageBeginWarp(); |
| mOnPageBeginWarpCalled = true; |
| } |
| mOnPageEndWarpCalled = false; |
| } |
| |
| private void dispatchOnPageEndWarp() { |
| if (!mOnPageEndWarpCalled) { |
| onPageEndWarp(); |
| mOnPageEndWarpCalled = true; |
| } |
| mOnPageBeginWarpCalled = false; |
| } |
| |
| protected void pageEndMoving() { |
| if (DEBUG_WARP) Log.v(TAG, "pageEndMoving(" + mIsPageMoving + ")"); |
| if (mIsPageMoving) { |
| mIsPageMoving = false; |
| if (isWarping()) { |
| if (mPageSwapIndex != -1) { |
| swapPages(mPageSwapIndex, mPageWarpIndex); |
| } |
| dispatchOnPageEndWarp(); |
| resetPageWarp(); |
| } |
| onPageEndMoving(); |
| } |
| } |
| |
| private void resetPageWarp() { |
| // TODO: Verify pages have been reset correctly |
| mPageSwapIndex = -1; |
| mPageWarpIndex = -1; |
| } |
| |
| protected boolean isPageMoving() { |
| return mIsPageMoving; |
| } |
| |
| // a method that subclasses can override to add behavior |
| protected void onPageBeginMoving() { |
| } |
| |
| // a method that subclasses can override to add behavior |
| protected void onPageEndMoving() { |
| } |
| |
| /** |
| * Registers the specified listener on each page contained in this workspace. |
| * |
| * @param l The listener used to respond to long clicks. |
| */ |
| @Override |
| public void setOnLongClickListener(OnLongClickListener l) { |
| mLongClickListener = l; |
| final int count = getPageCount(); |
| for (int i = 0; i < count; i++) { |
| getPageAt(i).setOnLongClickListener(l); |
| } |
| } |
| |
| @Override |
| public void scrollBy(int x, int y) { |
| scrollTo(mUnboundedScrollX + x, getScrollY() + y); |
| } |
| |
| @Override |
| public void scrollTo(int x, int y) { |
| mUnboundedScrollX = x; |
| |
| if (x < 0) { |
| super.scrollTo(0, y); |
| if (mAllowOverScroll) { |
| overScroll(x); |
| } |
| } else if (x > mMaxScrollX) { |
| super.scrollTo(mMaxScrollX, y); |
| if (mAllowOverScroll) { |
| overScroll(x - mMaxScrollX); |
| } |
| } else { |
| mOverScrollX = x; |
| super.scrollTo(x, y); |
| } |
| |
| mTouchX = x; |
| mSmoothingTime = System.nanoTime() / NANOTIME_DIV; |
| |
| // Update the last motion events when scrolling |
| if (isReordering(true)) { |
| float[] p = mapPointFromParentToView(this, mParentDownMotionX, mParentDownMotionY); |
| mLastMotionX = p[0]; |
| mLastMotionY = p[1]; |
| updateDragViewTranslationDuringDrag(); |
| } |
| } |
| |
| // we moved this functionality to a helper function so SmoothPagedView can reuse it |
| protected boolean computeScrollHelper() { |
| if (mScroller.computeScrollOffset()) { |
| // Don't bother scrolling if the page does not need to be moved |
| if (getScrollX() != mScroller.getCurrX() |
| || getScrollY() != mScroller.getCurrY() |
| || mOverScrollX != mScroller.getCurrX()) { |
| scrollTo(mScroller.getCurrX(), mScroller.getCurrY()); |
| } |
| invalidate(); |
| return true; |
| } else if (mNextPage != INVALID_PAGE) { |
| mCurrentPage = Math.max(0, Math.min(mNextPage, getPageCount() - 1)); |
| mNextPage = INVALID_PAGE; |
| notifyPageSwitched(); |
| |
| // We don't want to trigger a page end moving unless the page has settled |
| // and the user has stopped scrolling |
| if (mTouchState == TOUCH_STATE_REST) { |
| pageEndMoving(); |
| } |
| |
| onPostReorderingAnimationCompleted(); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public void computeScroll() { |
| computeScrollHelper(); |
| } |
| |
| protected boolean shouldSetTopAlignedPivotForWidget(int childIndex) { |
| return mTopAlignPageWhenShrinkingForBouncer; |
| } |
| |
| @Override |
| protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| if (!mIsDataReady || getChildCount() == 0) { |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| return; |
| } |
| |
| // We measure the dimensions of the PagedView to be larger than the pages so that when we |
| // zoom out (and scale down), the view is still contained in the parent |
| View parent = (View) getParent(); |
| int widthMode = MeasureSpec.getMode(widthMeasureSpec); |
| int widthSize = MeasureSpec.getSize(widthMeasureSpec); |
| int heightMode = MeasureSpec.getMode(heightMeasureSpec); |
| int heightSize = MeasureSpec.getSize(heightMeasureSpec); |
| // NOTE: We multiply by 1.5f to account for the fact that depending on the offset of the |
| // viewport, we can be at most one and a half screens offset once we scale down |
| DisplayMetrics dm = getResources().getDisplayMetrics(); |
| int maxSize = Math.max(dm.widthPixels, dm.heightPixels); |
| int parentWidthSize = (int) (1.5f * maxSize); |
| int parentHeightSize = maxSize; |
| int scaledWidthSize = (int) (parentWidthSize / mMinScale); |
| int scaledHeightSize = (int) (parentHeightSize / mMinScale); |
| mViewport.set(0, 0, widthSize, heightSize); |
| |
| if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) { |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| return; |
| } |
| |
| // Return early if we aren't given a proper dimension |
| if (widthSize <= 0 || heightSize <= 0) { |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| return; |
| } |
| |
| /* Allow the height to be set as WRAP_CONTENT. This allows the particular case |
| * of the All apps view on XLarge displays to not take up more space then it needs. Width |
| * is still not allowed to be set as WRAP_CONTENT since many parts of the code expect |
| * each page to have the same width. |
| */ |
| final int verticalPadding = getPaddingTop() + getPaddingBottom(); |
| final int horizontalPadding = getPaddingLeft() + getPaddingRight(); |
| |
| // The children are given the same width and height as the workspace |
| // unless they were set to WRAP_CONTENT |
| if (DEBUG) Log.d(TAG, "PagedView.onMeasure(): " + widthSize + ", " + heightSize); |
| if (DEBUG) Log.d(TAG, "PagedView.scaledSize: " + scaledWidthSize + ", " + scaledHeightSize); |
| if (DEBUG) Log.d(TAG, "PagedView.parentSize: " + parentWidthSize + ", " + parentHeightSize); |
| if (DEBUG) Log.d(TAG, "PagedView.horizontalPadding: " + horizontalPadding); |
| if (DEBUG) Log.d(TAG, "PagedView.verticalPadding: " + verticalPadding); |
| final int childCount = getChildCount(); |
| for (int i = 0; i < childCount; i++) { |
| // disallowing padding in paged view (just pass 0) |
| final View child = getPageAt(i); |
| final LayoutParams lp = (LayoutParams) child.getLayoutParams(); |
| |
| int childWidthMode; |
| if (lp.width == LayoutParams.WRAP_CONTENT) { |
| childWidthMode = MeasureSpec.AT_MOST; |
| } else { |
| childWidthMode = MeasureSpec.EXACTLY; |
| } |
| |
| int childHeightMode; |
| if (lp.height == LayoutParams.WRAP_CONTENT) { |
| childHeightMode = MeasureSpec.AT_MOST; |
| } else { |
| childHeightMode = MeasureSpec.EXACTLY; |
| } |
| |
| final int childWidthMeasureSpec = |
| MeasureSpec.makeMeasureSpec(widthSize - horizontalPadding, childWidthMode); |
| final int childHeightMeasureSpec = |
| MeasureSpec.makeMeasureSpec(heightSize - verticalPadding, childHeightMode); |
| |
| child.measure(childWidthMeasureSpec, childHeightMeasureSpec); |
| } |
| setMeasuredDimension(scaledWidthSize, scaledHeightSize); |
| |
| // We can't call getChildOffset/getRelativeChildOffset until we set the measured dimensions. |
| // We also wait until we set the measured dimensions before flushing the cache as well, to |
| // ensure that the cache is filled with good values. |
| invalidateCachedOffsets(); |
| |
| if (mChildCountOnLastMeasure != getChildCount() && !mDeferringForDelete) { |
| setCurrentPage(mCurrentPage); |
| } |
| mChildCountOnLastMeasure = getChildCount(); |
| |
| if (childCount > 0) { |
| if (DEBUG) Log.d(TAG, "getRelativeChildOffset(): " + getViewportWidth() + ", " |
| + getChildWidth(0)); |
| |
| // Calculate the variable page spacing if necessary |
| if (mPageSpacing == AUTOMATIC_PAGE_SPACING) { |
| // The gap between pages in the PagedView should be equal to the gap from the page |
| // to the edge of the screen (so it is not visible in the current screen). To |
| // account for unequal padding on each side of the paged view, we take the maximum |
| // of the left/right gap and use that as the gap between each page. |
| int offset = getRelativeChildOffset(0); |
| int spacing = Math.max(offset, widthSize - offset - |
| getChildAt(0).getMeasuredWidth()); |
| setPageSpacing(spacing); |
| } |
| } |
| |
| updateScrollingIndicatorPosition(); |
| |
| if (childCount > 0) { |
| mMaxScrollX = getChildOffset(childCount - 1) - getRelativeChildOffset(childCount - 1); |
| } else { |
| mMaxScrollX = 0; |
| } |
| } |
| |
| public void setPageSpacing(int pageSpacing) { |
| mPageSpacing = pageSpacing; |
| invalidateCachedOffsets(); |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| if (!mIsDataReady || getChildCount() == 0) { |
| return; |
| } |
| |
| if (DEBUG) Log.d(TAG, "PagedView.onLayout()"); |
| final int childCount = getChildCount(); |
| |
| int offsetX = getViewportOffsetX(); |
| int offsetY = getViewportOffsetY(); |
| |
| // Update the viewport offsets |
| mViewport.offset(offsetX, offsetY); |
| |
| int childLeft = offsetX + getRelativeChildOffset(0); |
| for (int i = 0; i < childCount; i++) { |
| final View child = getPageAt(i); |
| int childTop = offsetY + getPaddingTop(); |
| if (child.getVisibility() != View.GONE) { |
| final int childWidth = getScaledMeasuredWidth(child); |
| final int childHeight = child.getMeasuredHeight(); |
| |
| if (DEBUG) Log.d(TAG, "\tlayout-child" + i + ": " + childLeft + ", " + childTop); |
| child.layout(childLeft, childTop, |
| childLeft + child.getMeasuredWidth(), childTop + childHeight); |
| childLeft += childWidth + mPageSpacing; |
| } |
| } |
| |
| if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < getChildCount()) { |
| setHorizontalScrollBarEnabled(false); |
| updateCurrentPageScroll(); |
| setHorizontalScrollBarEnabled(true); |
| mFirstLayout = false; |
| } |
| // If a page was swapped when we rebuilt the layout, swap it again now. |
| if (mPageSwapIndex != -1) { |
| if (DEBUG_WARP) Log.v(TAG, "onLayout: swapping pages"); |
| swapPages(mPageSwapIndex, mPageWarpIndex); |
| } |
| } |
| |
| protected void screenScrolled(int screenCenter) { |
| } |
| |
| @Override |
| public void onChildViewAdded(View parent, View child) { |
| // This ensures that when children are added, they get the correct transforms / alphas |
| // in accordance with any scroll effects. |
| mForceScreenScrolled = true; |
| invalidate(); |
| invalidateCachedOffsets(); |
| } |
| |
| @Override |
| public void onChildViewRemoved(View parent, View child) { |
| mForceScreenScrolled = true; |
| invalidate(); |
| invalidateCachedOffsets(); |
| } |
| |
| protected void invalidateCachedOffsets() { |
| int count = getChildCount(); |
| if (count == 0) { |
| mChildOffsets = null; |
| mChildRelativeOffsets = null; |
| mChildOffsetsWithLayoutScale = null; |
| return; |
| } |
| |
| mChildOffsets = new int[count]; |
| mChildRelativeOffsets = new int[count]; |
| mChildOffsetsWithLayoutScale = new int[count]; |
| for (int i = 0; i < count; i++) { |
| mChildOffsets[i] = -1; |
| mChildRelativeOffsets[i] = -1; |
| mChildOffsetsWithLayoutScale[i] = -1; |
| } |
| } |
| |
| protected int getChildOffset(int index) { |
| if (index < 0 || index > getChildCount() - 1) return 0; |
| |
| int[] childOffsets = Float.compare(mLayoutScale, 1f) == 0 ? |
| mChildOffsets : mChildOffsetsWithLayoutScale; |
| |
| if (childOffsets != null && childOffsets[index] != -1) { |
| return childOffsets[index]; |
| } else { |
| if (getChildCount() == 0) |
| return 0; |
| |
| int offset = getRelativeChildOffset(0); |
| for (int i = 0; i < index; ++i) { |
| offset += getScaledMeasuredWidth(getPageAt(i)) + mPageSpacing; |
| } |
| if (childOffsets != null) { |
| childOffsets[index] = offset; |
| } |
| return offset; |
| } |
| } |
| |
| protected int getRelativeChildOffset(int index) { |
| if (index < 0 || index > getChildCount() - 1) return 0; |
| |
| if (mChildRelativeOffsets != null && mChildRelativeOffsets[index] != -1) { |
| return mChildRelativeOffsets[index]; |
| } else { |
| final int padding = getPaddingLeft() + getPaddingRight(); |
| final int offset = getPaddingLeft() + |
| (getViewportWidth() - padding - getChildWidth(index)) / 2; |
| if (mChildRelativeOffsets != null) { |
| mChildRelativeOffsets[index] = offset; |
| } |
| return offset; |
| } |
| } |
| |
| protected int getScaledMeasuredWidth(View child) { |
| // This functions are called enough times that it actually makes a difference in the |
| // profiler -- so just inline the max() here |
| final int measuredWidth = child.getMeasuredWidth(); |
| final int minWidth = mMinimumWidth; |
| final int maxWidth = (minWidth > measuredWidth) ? minWidth : measuredWidth; |
| return (int) (maxWidth * mLayoutScale + 0.5f); |
| } |
| |
| void boundByReorderablePages(boolean isReordering, int[] range) { |
| // Do nothing |
| } |
| |
| // TODO: Fix this |
| protected void getVisiblePages(int[] range) { |
| range[0] = 0; |
| range[1] = getPageCount() - 1; |
| |
| /* |
| final int pageCount = getChildCount(); |
| |
| if (pageCount > 0) { |
| final int screenWidth = getViewportWidth(); |
| int leftScreen = 0; |
| int rightScreen = 0; |
| int offsetX = getViewportOffsetX() + getScrollX(); |
| View currPage = getPageAt(leftScreen); |
| while (leftScreen < pageCount - 1 && |
| currPage.getX() + currPage.getWidth() - |
| currPage.getPaddingRight() < offsetX) { |
| leftScreen++; |
| currPage = getPageAt(leftScreen); |
| } |
| rightScreen = leftScreen; |
| currPage = getPageAt(rightScreen + 1); |
| while (rightScreen < pageCount - 1 && |
| currPage.getX() - currPage.getPaddingLeft() < offsetX + screenWidth) { |
| rightScreen++; |
| currPage = getPageAt(rightScreen + 1); |
| } |
| |
| // TEMP: this is a hacky way to ensure that animations to new pages are not clipped |
| // because we don't draw them while scrolling? |
| range[0] = Math.max(0, leftScreen - 1); |
| range[1] = Math.min(rightScreen + 1, getChildCount() - 1); |
| } else { |
| range[0] = -1; |
| range[1] = -1; |
| } |
| */ |
| } |
| |
| protected boolean shouldDrawChild(View child) { |
| return child.getAlpha() > 0; |
| } |
| |
| @Override |
| protected void dispatchDraw(Canvas canvas) { |
| int halfScreenSize = getViewportWidth() / 2; |
| // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. |
| // Otherwise it is equal to the scaled overscroll position. |
| int screenCenter = mOverScrollX + halfScreenSize; |
| |
| if (screenCenter != mLastScreenCenter || mForceScreenScrolled) { |
| // set mForceScreenScrolled before calling screenScrolled so that screenScrolled can |
| // set it for the next frame |
| mForceScreenScrolled = false; |
| screenScrolled(screenCenter); |
| mLastScreenCenter = screenCenter; |
| } |
| |
| // Find out which screens are visible; as an optimization we only call draw on them |
| final int pageCount = getChildCount(); |
| if (pageCount > 0) { |
| getVisiblePages(mTempVisiblePagesRange); |
| final int leftScreen = mTempVisiblePagesRange[0]; |
| final int rightScreen = mTempVisiblePagesRange[1]; |
| if (leftScreen != -1 && rightScreen != -1) { |
| final long drawingTime = getDrawingTime(); |
| // Clip to the bounds |
| canvas.save(); |
| canvas.clipRect(getScrollX(), getScrollY(), getScrollX() + getRight() - getLeft(), |
| getScrollY() + getBottom() - getTop()); |
| |
| // Draw all the children, leaving the drag view for last |
| for (int i = pageCount - 1; i >= 0; i--) { |
| final View v = getPageAt(i); |
| if (v == mDragView) continue; |
| if (mForceDrawAllChildrenNextFrame || |
| (leftScreen <= i && i <= rightScreen && shouldDrawChild(v))) { |
| drawChild(canvas, v, drawingTime); |
| } |
| } |
| // Draw the drag view on top (if there is one) |
| if (mDragView != null) { |
| drawChild(canvas, mDragView, drawingTime); |
| } |
| |
| mForceDrawAllChildrenNextFrame = false; |
| canvas.restore(); |
| } |
| } |
| } |
| |
| @Override |
| public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) { |
| int page = indexToPage(indexOfChild(child)); |
| if (page != mCurrentPage || !mScroller.isFinished()) { |
| snapToPage(page); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) { |
| int focusablePage; |
| if (mNextPage != INVALID_PAGE) { |
| focusablePage = mNextPage; |
| } else { |
| focusablePage = mCurrentPage; |
| } |
| View v = getPageAt(focusablePage); |
| if (v != null) { |
| return v.requestFocus(direction, previouslyFocusedRect); |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean dispatchUnhandledMove(View focused, int direction) { |
| if (direction == View.FOCUS_LEFT) { |
| if (getCurrentPage() > 0) { |
| snapToPage(getCurrentPage() - 1); |
| return true; |
| } |
| } else if (direction == View.FOCUS_RIGHT) { |
| if (getCurrentPage() < getPageCount() - 1) { |
| snapToPage(getCurrentPage() + 1); |
| return true; |
| } |
| } |
| return super.dispatchUnhandledMove(focused, direction); |
| } |
| |
| @Override |
| public void addFocusables(ArrayList<View> views, int direction, int focusableMode) { |
| if (mCurrentPage >= 0 && mCurrentPage < getPageCount()) { |
| getPageAt(mCurrentPage).addFocusables(views, direction, focusableMode); |
| } |
| if (direction == View.FOCUS_LEFT) { |
| if (mCurrentPage > 0) { |
| getPageAt(mCurrentPage - 1).addFocusables(views, direction, focusableMode); |
| } |
| } else if (direction == View.FOCUS_RIGHT){ |
| if (mCurrentPage < getPageCount() - 1) { |
| getPageAt(mCurrentPage + 1).addFocusables(views, direction, focusableMode); |
| } |
| } |
| } |
| |
| /** |
| * If one of our descendant views decides that it could be focused now, only |
| * pass that along if it's on the current page. |
| * |
| * This happens when live folders requery, and if they're off page, they |
| * end up calling requestFocus, which pulls it on page. |
| */ |
| @Override |
| public void focusableViewAvailable(View focused) { |
| View current = getPageAt(mCurrentPage); |
| View v = focused; |
| while (true) { |
| if (v == current) { |
| super.focusableViewAvailable(focused); |
| return; |
| } |
| if (v == this) { |
| return; |
| } |
| ViewParent parent = v.getParent(); |
| if (parent instanceof View) { |
| v = (View)v.getParent(); |
| } else { |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Return true if a tap at (x, y) should trigger a flip to the previous page. |
| */ |
| protected boolean hitsPreviousPage(float x, float y) { |
| return (x < getViewportOffsetX() + getRelativeChildOffset(mCurrentPage) - mPageSpacing); |
| } |
| |
| /** |
| * Return true if a tap at (x, y) should trigger a flip to the next page. |
| */ |
| protected boolean hitsNextPage(float x, float y) { |
| return (x > (getViewportOffsetX() + getViewportWidth() - getRelativeChildOffset(mCurrentPage) + mPageSpacing)); |
| } |
| |
| /** Returns whether x and y originated within the buffered viewport */ |
| private boolean isTouchPointInViewportWithBuffer(int x, int y) { |
| mTmpRect.set(mViewport.left - mViewport.width() / 2, mViewport.top, |
| mViewport.right + mViewport.width() / 2, mViewport.bottom); |
| return mTmpRect.contains(x, y); |
| } |
| |
| /** Returns whether x and y originated within the current page view bounds */ |
| private boolean isTouchPointInCurrentPage(int x, int y) { |
| View v = getPageAt(getCurrentPage()); |
| if (v != null) { |
| mTmpRect.set((v.getLeft() - getScrollX()), 0, (v.getRight() - getScrollX()), |
| v.getBottom()); |
| return mTmpRect.contains(x, y); |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean onInterceptTouchEvent(MotionEvent ev) { |
| if (DISABLE_TOUCH_INTERACTION) { |
| return false; |
| } |
| |
| /* |
| * This method JUST determines whether we want to intercept the motion. |
| * If we return true, onTouchEvent will be called and we do the actual |
| * scrolling there. |
| */ |
| acquireVelocityTrackerAndAddMovement(ev); |
| |
| // Skip touch handling if there are no pages to swipe |
| if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev); |
| |
| /* |
| * Shortcut the most recurring case: the user is in the dragging |
| * state and he is moving his finger. We want to intercept this |
| * motion. |
| */ |
| final int action = ev.getAction(); |
| if ((action == MotionEvent.ACTION_MOVE) && |
| (mTouchState == TOUCH_STATE_SCROLLING)) { |
| return true; |
| } |
| |
| switch (action & MotionEvent.ACTION_MASK) { |
| case MotionEvent.ACTION_MOVE: { |
| /* |
| * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check |
| * whether the user has moved far enough from his original down touch. |
| */ |
| if (mActivePointerId != INVALID_POINTER) { |
| if (mIsCameraEvent || determineScrollingStart(ev)) { |
| startScrolling(ev); |
| } |
| break; |
| } |
| // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN |
| // event. in that case, treat the first occurence of a move event as a ACTION_DOWN |
| // i.e. fall through to the next case (don't break) |
| // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events |
| // while it's small- this was causing a crash before we checked for INVALID_POINTER) |
| |
| break; |
| } |
| |
| case MotionEvent.ACTION_DOWN: { |
| if (mIsCameraEvent) { |
| animateWarpPageOnScreen("interceptTouch(): DOWN"); |
| } |
| // Remember where the motion event started |
| saveDownState(ev); |
| |
| /* |
| * If being flinged and user touches the screen, initiate drag; |
| * otherwise don't. mScroller.isFinished should be false when |
| * being flinged. |
| */ |
| final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX()); |
| final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop); |
| if (finishedScrolling) { |
| setTouchState(TOUCH_STATE_REST); |
| mScroller.abortAnimation(); |
| } else { |
| if (mIsCameraEvent || isTouchPointInViewportWithBuffer( |
| (int) mDownMotionX, (int) mDownMotionY)) { |
| setTouchState(TOUCH_STATE_SCROLLING); |
| } else { |
| setTouchState(TOUCH_STATE_REST); |
| } |
| } |
| |
| // check if this can be the beginning of a tap on the side of the pages |
| // to scroll the current page |
| if (!DISABLE_TOUCH_SIDE_PAGES) { |
| if (mTouchState != TOUCH_STATE_PREV_PAGE |
| && mTouchState != TOUCH_STATE_NEXT_PAGE) { |
| if (getChildCount() > 0) { |
| float x = ev.getX(); |
| float y = ev.getY(); |
| if (hitsPreviousPage(x, y)) { |
| setTouchState(TOUCH_STATE_PREV_PAGE); |
| } else if (hitsNextPage(x, y)) { |
| setTouchState(TOUCH_STATE_NEXT_PAGE); |
| } |
| } |
| } |
| } |
| break; |
| } |
| |
| case MotionEvent.ACTION_UP: |
| case MotionEvent.ACTION_CANCEL: |
| resetTouchState(); |
| // Just intercept the touch event on up if we tap outside the strict viewport |
| if (!isTouchPointInCurrentPage((int) mLastMotionX, (int) mLastMotionY)) { |
| return true; |
| } |
| break; |
| |
| case MotionEvent.ACTION_POINTER_UP: |
| onSecondaryPointerUp(ev); |
| releaseVelocityTracker(); |
| break; |
| } |
| |
| /* |
| * The only time we want to intercept motion events is if we are in the |
| * drag mode. |
| */ |
| return mTouchState != TOUCH_STATE_REST; |
| } |
| |
| private void setTouchState(int touchState) { |
| if (mTouchState != touchState) { |
| if (DEBUG_WARP) Log.v(TAG, "mTouchState changing to " + touchState); |
| onTouchStateChanged(touchState); |
| mTouchState = touchState; |
| } |
| } |
| |
| void onTouchStateChanged(int newTouchState) { |
| if (DEBUG) { |
| Log.v(TAG, "onTouchStateChanged(old="+ mTouchState + ", new=" + newTouchState + ")"); |
| } |
| } |
| |
| /** |
| * Save the state when we get {@link MotionEvent#ACTION_DOWN} |
| * @param ev |
| */ |
| private void saveDownState(MotionEvent ev) { |
| // Remember where the motion event started |
| mDownMotionX = mLastMotionX = ev.getX(); |
| mDownMotionY = mLastMotionY = ev.getY(); |
| mDownScrollX = getScrollX(); |
| float[] p = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY); |
| mParentDownMotionX = p[0]; |
| mParentDownMotionY = p[1]; |
| mLastMotionXRemainder = 0; |
| mTotalMotionX = 0; |
| mActivePointerId = ev.getPointerId(0); |
| |
| // Determine if the down event is within the threshold to be an edge swipe |
| int leftEdgeBoundary = getViewportOffsetX() + mEdgeSwipeRegionSize; |
| int rightEdgeBoundary = getMeasuredWidth() - getViewportOffsetX() - mEdgeSwipeRegionSize; |
| if ((mDownMotionX <= leftEdgeBoundary || mDownMotionX >= rightEdgeBoundary)) { |
| mDownEventOnEdge = true; |
| } |
| } |
| |
| /* |
| * Determines if we should change the touch state to start scrolling after the |
| * user moves their touch point too far. |
| */ |
| protected boolean determineScrollingStart(MotionEvent ev) { |
| // Disallow scrolling if we don't have a valid pointer index |
| final int pointerIndex = ev.findPointerIndex(mActivePointerId); |
| if (pointerIndex == -1) return false; |
| |
| // Disallow scrolling if we started the gesture from outside the viewport |
| final float x = ev.getX(pointerIndex); |
| final float y = ev.getY(pointerIndex); |
| if (!isTouchPointInViewportWithBuffer((int) x, (int) y)) return false; |
| |
| // If we're only allowing edge swipes, we break out early if the down event wasn't |
| // at the edge. |
| if (mOnlyAllowEdgeSwipes && !mDownEventOnEdge) return false; |
| |
| final int xDiff = (int) Math.abs(x - mLastMotionX); |
| final int yDiff = (int) Math.abs(y - mLastMotionY); |
| |
| final int touchSlop = Math.round(TOUCH_SLOP_SCALE * mTouchSlop); |
| boolean xPaged = xDiff > mPagingTouchSlop; |
| boolean xMoved = xDiff > touchSlop; |
| boolean yMoved = yDiff > touchSlop; |
| |
| return (xMoved || xPaged || yMoved) && (mUsePagingTouchSlop ? xPaged : xMoved); |
| } |
| |
| private void startScrolling(MotionEvent ev) { |
| // Ignore if we don't have a valid pointer index |
| final int pointerIndex = ev.findPointerIndex(mActivePointerId); |
| if (pointerIndex == -1) return; |
| |
| final float x = ev.getX(pointerIndex); |
| setTouchState(TOUCH_STATE_SCROLLING); |
| mTotalMotionX += Math.abs(mLastMotionX - x); |
| mLastMotionX = x; |
| mLastMotionXRemainder = 0; |
| mTouchX = getViewportOffsetX() + getScrollX(); |
| mSmoothingTime = System.nanoTime() / NANOTIME_DIV; |
| pageBeginMoving(); |
| } |
| |
| protected float getMaxScrollProgress() { |
| return 1.0f; |
| } |
| |
| protected float getBoundedScrollProgress(int screenCenter, View v, int page) { |
| final int halfScreenSize = getViewportWidth() / 2; |
| |
| screenCenter = Math.min(mScrollX + halfScreenSize, screenCenter); |
| screenCenter = Math.max(halfScreenSize, screenCenter); |
| |
| return getScrollProgress(screenCenter, v, page); |
| } |
| |
| protected float getScrollProgress(int screenCenter, View v, int page) { |
| final int halfScreenSize = getViewportWidth() / 2; |
| |
| int totalDistance = getScaledMeasuredWidth(v) + mPageSpacing; |
| int delta = screenCenter - (getChildOffset(page) - |
| getRelativeChildOffset(page) + halfScreenSize); |
| |
| float scrollProgress = delta / (totalDistance * 1.0f); |
| scrollProgress = Math.min(scrollProgress, getMaxScrollProgress()); |
| scrollProgress = Math.max(scrollProgress, - getMaxScrollProgress()); |
| return scrollProgress; |
| } |
| |
| // This curve determines how the effect of scrolling over the limits of the page dimishes |
| // as the user pulls further and further from the bounds |
| private float overScrollInfluenceCurve(float f) { |
| f -= 1.0f; |
| return f * f * f + 1.0f; |
| } |
| |
| protected void acceleratedOverScroll(float amount) { |
| int screenSize = getViewportWidth(); |
| |
| // We want to reach the max over scroll effect when the user has |
| // over scrolled half the size of the screen |
| float f = OVERSCROLL_ACCELERATE_FACTOR * (amount / screenSize); |
| |
| if (f == 0) return; |
| |
| // Clamp this factor, f, to -1 < f < 1 |
| if (Math.abs(f) >= 1) { |
| f /= Math.abs(f); |
| } |
| |
| int overScrollAmount = (int) Math.round(f * screenSize); |
| if (amount < 0) { |
| mOverScrollX = overScrollAmount; |
| super.scrollTo(0, getScrollY()); |
| } else { |
| mOverScrollX = mMaxScrollX + overScrollAmount; |
| super.scrollTo(mMaxScrollX, getScrollY()); |
| } |
| invalidate(); |
| } |
| |
| protected void dampedOverScroll(float amount) { |
| int screenSize = getViewportWidth(); |
| |
| float f = (amount / screenSize); |
| |
| if (f == 0) return; |
| f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f))); |
| |
| // Clamp this factor, f, to -1 < f < 1 |
| if (Math.abs(f) >= 1) { |
| f /= Math.abs(f); |
| } |
| |
| int overScrollAmount = (int) Math.round(OVERSCROLL_DAMP_FACTOR * f * screenSize); |
| if (amount < 0) { |
| mOverScrollX = overScrollAmount; |
| super.scrollTo(0, getScrollY()); |
| } else { |
| mOverScrollX = mMaxScrollX + overScrollAmount; |
| super.scrollTo(mMaxScrollX, getScrollY()); |
| } |
| invalidate(); |
| } |
| |
| protected void overScroll(float amount) { |
| dampedOverScroll(amount); |
| } |
| |
| protected float maxOverScroll() { |
| // Using the formula in overScroll, assuming that f = 1.0 (which it should generally not |
| // exceed). Used to find out how much extra wallpaper we need for the over scroll effect |
| float f = 1.0f; |
| f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f))); |
| return OVERSCROLL_DAMP_FACTOR * f; |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent ev) { |
| if (DISABLE_TOUCH_INTERACTION) { |
| return false; |
| } |
| |
| // Skip touch handling if there are no pages to swipe |
| if (getChildCount() <= 0) return super.onTouchEvent(ev); |
| |
| acquireVelocityTrackerAndAddMovement(ev); |
| |
| final int action = ev.getAction(); |
| |
| switch (action & MotionEvent.ACTION_MASK) { |
| case MotionEvent.ACTION_DOWN: |
| /* |
| * If being flinged and user touches, stop the fling. isFinished |
| * will be false if being flinged. |
| */ |
| if (!mScroller.isFinished()) { |
| mScroller.abortAnimation(); |
| } |
| |
| // Remember where the motion event started |
| saveDownState(ev); |
| |
| if (mTouchState == TOUCH_STATE_SCROLLING) { |
| pageBeginMoving(); |
| } else { |
| setTouchState(TOUCH_STATE_READY); |
| } |
| |
| if (mIsCameraEvent) { |
| animateWarpPageOnScreen("onTouch(): DOWN"); |
| } |
| break; |
| |
| case MotionEvent.ACTION_MOVE: |
| if (mTouchState == TOUCH_STATE_SCROLLING) { |
| // Scroll to follow the motion event |
| final int pointerIndex = ev.findPointerIndex(mActivePointerId); |
| |
| if (pointerIndex == -1) return true; |
| |
| final float x = ev.getX(pointerIndex); |
| final float deltaX = mLastMotionX + mLastMotionXRemainder - x; |
| |
| mTotalMotionX += Math.abs(deltaX); |
| |
| // Only scroll and update mLastMotionX if we have moved some discrete amount. We |
| // keep the remainder because we are actually testing if we've moved from the last |
| // scrolled position (which is discrete). |
| if (Math.abs(deltaX) >= 1.0f) { |
| mTouchX += deltaX; |
| mSmoothingTime = System.nanoTime() / NANOTIME_DIV; |
| if (isWarping()) { |
| KeyguardWidgetFrame v = (KeyguardWidgetFrame) getPageAt(mPageWarpIndex); |
| v.setTranslationX(v.getTranslationX() - deltaX); |
| } else if (!mDeferScrollUpdate) { |
| scrollBy((int) deltaX, 0); |
| if (DEBUG) Log.d(TAG, "onTouchEvent().Scrolling: " + deltaX); |
| } else { |
| invalidate(); |
| } |
| mLastMotionX = x; |
| mLastMotionXRemainder = deltaX - (int) deltaX; |
| } else { |
| awakenScrollBars(); |
| } |
| } else if (mTouchState == TOUCH_STATE_REORDERING) { |
| // Update the last motion position |
| mLastMotionX = ev.getX(); |
| mLastMotionY = ev.getY(); |
| |
| // Update the parent down so that our zoom animations take this new movement into |
| // account |
| float[] pt = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY); |
| mParentDownMotionX = pt[0]; |
| mParentDownMotionY = pt[1]; |
| updateDragViewTranslationDuringDrag(); |
| |
| // Find the closest page to the touch point |
| final int dragViewIndex = indexOfChild(mDragView); |
| int bufferSize = (int) (REORDERING_SIDE_PAGE_BUFFER_PERCENTAGE * |
| getViewportWidth()); |
| int leftBufferEdge = (int) (mapPointFromViewToParent(this, mViewport.left, 0)[0] |
| + bufferSize); |
| int rightBufferEdge = (int) (mapPointFromViewToParent(this, mViewport.right, 0)[0] |
| - bufferSize); |
| |
| // Change the drag view if we are hovering over the drop target |
| boolean isHoveringOverDelete = isHoveringOverDeleteDropTarget( |
| (int) mParentDownMotionX, (int) mParentDownMotionY); |
| setPageHoveringOverDeleteDropTarget(dragViewIndex, isHoveringOverDelete); |
| |
| if (DEBUG) Log.d(TAG, "leftBufferEdge: " + leftBufferEdge); |
| if (DEBUG) Log.d(TAG, "rightBufferEdge: " + rightBufferEdge); |
| if (DEBUG) Log.d(TAG, "mLastMotionX: " + mLastMotionX); |
| if (DEBUG) Log.d(TAG, "mLastMotionY: " + mLastMotionY); |
| if (DEBUG) Log.d(TAG, "mParentDownMotionX: " + mParentDownMotionX); |
| if (DEBUG) Log.d(TAG, "mParentDownMotionY: " + mParentDownMotionY); |
| |
| float parentX = mParentDownMotionX; |
| int pageIndexToSnapTo = -1; |
| if (parentX < leftBufferEdge && dragViewIndex > 0) { |
| pageIndexToSnapTo = dragViewIndex - 1; |
| } else if (parentX > rightBufferEdge && dragViewIndex < getChildCount() - 1) { |
| pageIndexToSnapTo = dragViewIndex + 1; |
| } |
| |
| final int pageUnderPointIndex = pageIndexToSnapTo; |
| if (pageUnderPointIndex > -1 && !isHoveringOverDelete) { |
| mTempVisiblePagesRange[0] = 0; |
| mTempVisiblePagesRange[1] = getPageCount() - 1; |
| boundByReorderablePages(true, mTempVisiblePagesRange); |
| if (mTempVisiblePagesRange[0] <= pageUnderPointIndex && |
| pageUnderPointIndex <= mTempVisiblePagesRange[1] && |
| pageUnderPointIndex != mSidePageHoverIndex && mScroller.isFinished()) { |
| mSidePageHoverIndex = pageUnderPointIndex; |
| mSidePageHoverRunnable = new Runnable() { |
| @Override |
| public void run() { |
| // Update the down scroll position to account for the fact that the |
| // current page is moved |
| mDownScrollX = getChildOffset(pageUnderPointIndex) |
| - getRelativeChildOffset(pageUnderPointIndex); |
| |
| // Setup the scroll to the correct page before we swap the views |
| snapToPage(pageUnderPointIndex); |
| |
| // For each of the pages between the paged view and the drag view, |
| // animate them from the previous position to the new position in |
| // the layout (as a result of the drag view moving in the layout) |
| int shiftDelta = (dragViewIndex < pageUnderPointIndex) ? -1 : 1; |
| int lowerIndex = (dragViewIndex < pageUnderPointIndex) ? |
| dragViewIndex + 1 : pageUnderPointIndex; |
| int upperIndex = (dragViewIndex > pageUnderPointIndex) ? |
| dragViewIndex - 1 : pageUnderPointIndex; |
| for (int i = lowerIndex; i <= upperIndex; ++i) { |
| View v = getChildAt(i); |
| // dragViewIndex < pageUnderPointIndex, so after we remove the |
| // drag view all subsequent views to pageUnderPointIndex will |
| // shift down. |
| int oldX = getViewportOffsetX() + getChildOffset(i); |
| int newX = getViewportOffsetX() + getChildOffset(i + shiftDelta); |
| |
| // Animate the view translation from its old position to its new |
| // position |
| AnimatorSet anim = (AnimatorSet) v.getTag(); |
| if (anim != null) { |
| anim.cancel(); |
| } |
| |
| v.setTranslationX(oldX - newX); |
| anim = new AnimatorSet(); |
| anim.setDuration(REORDERING_REORDER_REPOSITION_DURATION); |
| anim.playTogether( |
| ObjectAnimator.ofFloat(v, "translationX", 0f)); |
| anim.start(); |
| v.setTag(anim); |
| } |
| |
| removeView(mDragView); |
| onRemoveView(mDragView, false); |
| addView(mDragView, pageUnderPointIndex); |
| onAddView(mDragView, pageUnderPointIndex); |
| mSidePageHoverIndex = -1; |
| } |
| }; |
| postDelayed(mSidePageHoverRunnable, REORDERING_SIDE_PAGE_HOVER_TIMEOUT); |
| } |
| } else { |
| removeCallbacks(mSidePageHoverRunnable); |
| mSidePageHoverIndex = -1; |
| } |
| } else if (mIsCameraEvent || determineScrollingStart(ev)) { |
| startScrolling(ev); |
| } |
| break; |
| |
| case MotionEvent.ACTION_UP: |
| if (mTouchState == TOUCH_STATE_SCROLLING) { |
| final int activePointerId = mActivePointerId; |
| final int pointerIndex = ev.findPointerIndex(activePointerId); |
| |
| if (pointerIndex == -1) return true; |
| |
| final float x = ev.getX(pointerIndex); |
| final VelocityTracker velocityTracker = mVelocityTracker; |
| velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity); |
| int velocityX = (int) velocityTracker.getXVelocity(activePointerId); |
| final int deltaX = (int) (x - mDownMotionX); |
| final int pageWidth = getScaledMeasuredWidth(getPageAt(mCurrentPage)); |
| boolean isSignificantMove = Math.abs(deltaX) > pageWidth * |
| SIGNIFICANT_MOVE_THRESHOLD; |
| |
| mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x); |
| |
| boolean isFling = mTotalMotionX > MIN_LENGTH_FOR_FLING && |
| Math.abs(velocityX) > mFlingThresholdVelocity; |
| |
| // In the case that the page is moved far to one direction and then is flung |
| // in the opposite direction, we use a threshold to determine whether we should |
| // just return to the starting page, or if we should skip one further. |
| boolean returnToOriginalPage = false; |
| if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD && |
| Math.signum(velocityX) != Math.signum(deltaX) && isFling) { |
| returnToOriginalPage = true; |
| } |
| |
| int finalPage; |
| // We give flings precedence over large moves, which is why we short-circuit our |
| // test for a large move if a fling has been registered. That is, a large |
| // move to the left and fling to the right will register as a fling to the right. |
| if (((isSignificantMove && deltaX > 0 && !isFling) || |
| (isFling && velocityX > 0)) && mCurrentPage > 0) { |
| finalPage = returnToOriginalPage || isWarping() |
| ? mCurrentPage : mCurrentPage - 1; |
| snapToPageWithVelocity(finalPage, velocityX); |
| } else if (((isSignificantMove && deltaX < 0 && !isFling) || |
| (isFling && velocityX < 0)) && |
| mCurrentPage < getChildCount() - 1) { |
| finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage + 1; |
| snapToPageWithVelocity(finalPage, velocityX); |
| } else { |
| snapToDestination(); |
| } |
| } else if (mTouchState == TOUCH_STATE_PREV_PAGE) { |
| // at this point we have not moved beyond the touch slop |
| // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so |
| // we can just page |
| int nextPage = Math.max(0, mCurrentPage - 1); |
| if (nextPage != mCurrentPage) { |
| snapToPage(nextPage); |
| } else { |
| snapToDestination(); |
| } |
| } else if (mTouchState == TOUCH_STATE_NEXT_PAGE) { |
| // at this point we have not moved beyond the touch slop |
| // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so |
| // we can just page |
| int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1); |
| if (nextPage != mCurrentPage) { |
| snapToPage(nextPage); |
| } else { |
| snapToDestination(); |
| } |
| } else if (mTouchState == TOUCH_STATE_REORDERING) { |
| // Update the last motion position |
| mLastMotionX = ev.getX(); |
| mLastMotionY = ev.getY(); |
| |
| // Update the parent down so that our zoom animations take this new movement into |
| // account |
| float[] pt = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY); |
| mParentDownMotionX = pt[0]; |
| mParentDownMotionY = pt[1]; |
| updateDragViewTranslationDuringDrag(); |
| boolean handledFling = false; |
| if (!DISABLE_FLING_TO_DELETE) { |
| // Check the velocity and see if we are flinging-to-delete |
| PointF flingToDeleteVector = isFlingingToDelete(); |
| if (flingToDeleteVector != null) { |
| onFlingToDelete(flingToDeleteVector); |
| handledFling = true; |
| } |
| } |
| if (!handledFling && isHoveringOverDeleteDropTarget((int) mParentDownMotionX, |
| (int) mParentDownMotionY)) { |
| onDropToDelete(); |
| } |
| } else { |
| if (DEBUG_WARP) Log.v(TAG, "calling onUnhandledTap()"); |
| if (mWarpPageExposed && !isAnimatingWarpPage()) { |
| animateWarpPageOffScreen("unhandled tap", true); |
| } |
| onUnhandledTap(ev); |
| } |
| |
| // Remove the callback to wait for the side page hover timeout |
| removeCallbacks(mSidePageHoverRunnable); |
| // End any intermediate reordering states |
| resetTouchState(); |
| break; |
| |
| case MotionEvent.ACTION_CANCEL: |
| if (mTouchState == TOUCH_STATE_SCROLLING) { |
| snapToDestination(); |
| } |
| resetTouchState(); |
| break; |
| |
| case MotionEvent.ACTION_POINTER_UP: |
| onSecondaryPointerUp(ev); |
| break; |
| } |
| |
| return true; |
| } |
| |
| //public abstract void onFlingToDelete(View v); |
| public abstract void onRemoveView(View v, boolean deletePermanently); |
| public abstract void onRemoveViewAnimationCompleted(); |
| public abstract void onAddView(View v, int index); |
| |
| private void resetTouchState() { |
| releaseVelocityTracker(); |
| endReordering(); |
| setTouchState(TOUCH_STATE_REST); |
| mActivePointerId = INVALID_POINTER; |
| mDownEventOnEdge = false; |
| } |
| |
| protected void onUnhandledTap(MotionEvent ev) {} |
| |
| @Override |
| public boolean onGenericMotionEvent(MotionEvent event) { |
| if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) { |
| switch (event.getAction()) { |
| case MotionEvent.ACTION_SCROLL: { |
| // Handle mouse (or ext. device) by shifting the page depending on the scroll |
| final float vscroll; |
| final float hscroll; |
| if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) { |
| vscroll = 0; |
| hscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL); |
| } else { |
| vscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL); |
| hscroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL); |
| } |
| if (hscroll != 0 || vscroll != 0) { |
| if (hscroll > 0 || vscroll > 0) { |
| scrollRight(); |
| } else { |
| scrollLeft(); |
| } |
| return true; |
| } |
| } |
| } |
| } |
| return super.onGenericMotionEvent(event); |
| } |
| |
| private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) { |
| if (mVelocityTracker == null) { |
| mVelocityTracker = VelocityTracker.obtain(); |
| } |
| mVelocityTracker.addMovement(ev); |
| } |
| |
| private void releaseVelocityTracker() { |
| if (mVelocityTracker != null) { |
| mVelocityTracker.recycle(); |
| mVelocityTracker = null; |
| } |
| } |
| |
| private void onSecondaryPointerUp(MotionEvent ev) { |
| final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >> |
| MotionEvent.ACTION_POINTER_INDEX_SHIFT; |
| final int pointerId = ev.getPointerId(pointerIndex); |
| if (pointerId == mActivePointerId) { |
| // This was our active pointer going up. Choose a new |
| // active pointer and adjust accordingly. |
| // TODO: Make this decision more intelligent. |
| final int newPointerIndex = pointerIndex == 0 ? 1 : 0; |
| mLastMotionX = mDownMotionX = ev.getX(newPointerIndex); |
| mLastMotionY = ev.getY(newPointerIndex); |
| mLastMotionXRemainder = 0; |
| mActivePointerId = ev.getPointerId(newPointerIndex); |
| if (mVelocityTracker != null) { |
| mVelocityTracker.clear(); |
| } |
| } |
| } |
| |
| @Override |
| public void requestChildFocus(View child, View focused) { |
| super.requestChildFocus(child, focused); |
| int page = indexToPage(indexOfChild(child)); |
| if (page >= 0 && page != getCurrentPage() && !isInTouchMode()) { |
| snapToPage(page); |
| } |
| } |
| |
| protected int getChildIndexForRelativeOffset(int relativeOffset) { |
| final int childCount = getChildCount(); |
| int left; |
| int right; |
| for (int i = 0; i < childCount; ++i) { |
| left = getRelativeChildOffset(i); |
| right = (left + getScaledMeasuredWidth(getPageAt(i))); |
| if (left <= relativeOffset && relativeOffset <= right) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| |
| protected int getChildWidth(int index) { |
| // This functions are called enough times that it actually makes a difference in the |
| // profiler -- so just inline the max() here |
| final int measuredWidth = getPageAt(index).getMeasuredWidth(); |
| final int minWidth = mMinimumWidth; |
| return (minWidth > measuredWidth) ? minWidth : measuredWidth; |
| } |
| |
| int getPageNearestToPoint(float x) { |
| int index = 0; |
| for (int i = 0; i < getChildCount(); ++i) { |
| if (x < getChildAt(i).getRight() - getScrollX()) { |
| return index; |
| } else { |
| index++; |
| } |
| } |
| return Math.min(index, getChildCount() - 1); |
| } |
| |
| int getPageNearestToCenterOfScreen() { |
| int minDistanceFromScreenCenter = Integer.MAX_VALUE; |
| int minDistanceFromScreenCenterIndex = -1; |
| int screenCenter = getViewportOffsetX() + getScrollX() + (getViewportWidth() / 2); |
| final int childCount = getChildCount(); |
| for (int i = 0; i < childCount; ++i) { |
| View layout = (View) getPageAt(i); |
| int childWidth = getScaledMeasuredWidth(layout); |
| int halfChildWidth = (childWidth / 2); |
| int childCenter = getViewportOffsetX() + getChildOffset(i) + halfChildWidth; |
| int distanceFromScreenCenter = Math.abs(childCenter - screenCenter); |
| if (distanceFromScreenCenter < minDistanceFromScreenCenter) { |
| minDistanceFromScreenCenter = distanceFromScreenCenter; |
| minDistanceFromScreenCenterIndex = i; |
| } |
| } |
| return minDistanceFromScreenCenterIndex; |
| } |
| |
| protected void snapToDestination() { |
| final int newPage = getPageNearestToCenterOfScreen(); |
| if (isWarping()) { |
| cancelWarpAnimation("snapToDestination", mCurrentPage != newPage); |
| } |
| snapToPage(newPage, getPageSnapDuration()); |
| } |
| |
| private int getPageSnapDuration() { |
| return isWarping() ? WARP_SNAP_DURATION : PAGE_SNAP_ANIMATION_DURATION; |
| } |
| |
| private static class ScrollInterpolator implements Interpolator { |
| public ScrollInterpolator() { |
| } |
| |
| public float getInterpolation(float t) { |
| t -= 1.0f; |
| return t*t*t*t*t + 1; |
| } |
| } |
| |
| // We want the duration of the page snap animation to be influenced by the distance that |
| // the screen has to travel, however, we don't want this duration to be effected in a |
| // purely linear fashion. Instead, we use this method to moderate the effect that the distance |
| // of travel has on the overall snap duration. |
| float distanceInfluenceForSnapDuration(float f) { |
| f -= 0.5f; // center the values about 0. |
| f *= 0.3f * Math.PI / 2.0f; |
| return (float) Math.sin(f); |
| } |
| |
| protected void snapToPageWithVelocity(int whichPage, int velocity) { |
| whichPage = Math.max(0, Math.min(whichPage, getChildCount() - 1)); |
| int halfScreenSize = getViewportWidth() / 2; |
| |
| if (isWarping()) { |
| cancelWarpAnimation("snapToPageWithVelocity", mCurrentPage != whichPage); |
| } |
| |
| if (DEBUG) Log.d(TAG, "snapToPage.getChildOffset(): " + getChildOffset(whichPage)); |
| if (DEBUG) Log.d(TAG, "snapToPageWithVelocity.getRelativeChildOffset(): " |
| + getViewportWidth() + ", " + getChildWidth(whichPage)); |
| final int newX = getChildOffset(whichPage) - getRelativeChildOffset(whichPage); |
| int delta = newX - mUnboundedScrollX; |
| int duration = 0; |
| |
| if (Math.abs(velocity) < mMinFlingVelocity) { |
| // If the velocity is low enough, then treat this more as an automatic page advance |
| // as opposed to an apparent physical response to flinging |
| snapToPage(whichPage, getPageSnapDuration()); |
| return; |
| } |
| |
| // Here we compute a "distance" that will be used in the computation of the overall |
| // snap duration. This is a function of the actual distance that needs to be traveled; |
| // we keep this value close to half screen size in order to reduce the variance in snap |
| // duration as a function of the distance the page needs to travel. |
| float distanceRatio = Math.min(1f, 1.0f * Math.abs(delta) / (2 * halfScreenSize)); |
| float distance = halfScreenSize + halfScreenSize * |
| distanceInfluenceForSnapDuration(distanceRatio); |
| |
| velocity = Math.abs(velocity); |
| velocity = Math.max(mMinSnapVelocity, velocity); |
| |
| // we want the page's snap velocity to approximately match the velocity at which the |
| // user flings, so we scale the duration by a value near to the derivative of the scroll |
| // interpolator at zero, ie. 5. We use 4 to make it a little slower. |
| duration = 4 * Math.round(1000 * Math.abs(distance / velocity)); |
| |
| snapToPage(whichPage, delta, duration); |
| } |
| |
| protected void snapToPage(int whichPage) { |
| snapToPage(whichPage, getPageSnapDuration()); |
| } |
| protected void snapToPageImmediately(int whichPage) { |
| snapToPage(whichPage, getPageSnapDuration(), true); |
| } |
| |
| protected void snapToPage(int whichPage, int duration) { |
| snapToPage(whichPage, duration, false); |
| } |
| protected void snapToPage(int whichPage, int duration, boolean immediate) { |
| whichPage = Math.max(0, Math.min(whichPage, getPageCount() - 1)); |
| |
| if (DEBUG) Log.d(TAG, "snapToPage.getChildOffset(): " + getChildOffset(whichPage)); |
| if (DEBUG) Log.d(TAG, "snapToPage.getRelativeChildOffset(): " + getViewportWidth() + ", " |
| + getChildWidth(whichPage)); |
| int newX = getChildOffset(whichPage) - getRelativeChildOffset(whichPage); |
| final int sX = mUnboundedScrollX; |
| final int delta = newX - sX; |
| snapToPage(whichPage, delta, duration, immediate); |
| } |
| |
| protected void snapToPage(int whichPage, int delta, int duration) { |
| snapToPage(whichPage, delta, duration, false); |
| } |
| |
| protected void snapToPage(int whichPage, int delta, int duration, boolean immediate) { |
| if (mPageSwapIndex != -1 && whichPage == mPageSwapIndex) { |
| mNextPage = mPageWarpIndex; // jump to the warp page |
| if (DEBUG_WARP) Log.v(TAG, "snapToPage(" + whichPage + ") : reset mPageSwapIndex"); |
| } else { |
| mNextPage = whichPage; |
| } |
| |
| if (isWarping()) { |
| dispatchOnPageEndWarp(); |
| notifyPageSwitching(whichPage); |
| resetPageWarp(); |
| } else { |
| notifyPageSwitching(whichPage); |
| } |
| |
| View focusedChild = getFocusedChild(); |
| if (focusedChild != null && whichPage != mCurrentPage && |
| focusedChild == getPageAt(mCurrentPage)) { |
| focusedChild.clearFocus(); |
| } |
| |
| pageBeginMoving(); |
| awakenScrollBars(duration); |
| if (immediate) { |
| duration = 0; |
| } else if (duration == 0) { |
| duration = Math.abs(delta); |
| } |
| |
| if (!mScroller.isFinished()) mScroller.abortAnimation(); |
| mScroller.startScroll(mUnboundedScrollX, 0, delta, 0, duration); |
| |
| notifyPageSwitched(); |
| |
| // Trigger a compute() to finish switching pages if necessary |
| if (immediate) { |
| computeScroll(); |
| } |
| |
| mForceScreenScrolled = true; |
| invalidate(); |
| } |
| |
| protected boolean isWarping() { |
| return mPageWarpIndex != -1; |
| } |
| |
| public void scrollLeft() { |
| if (mScroller.isFinished()) { |
| if (mCurrentPage > 0) snapToPage(mCurrentPage - 1); |
| } else { |
| if (mNextPage > 0) snapToPage(mNextPage - 1); |
| } |
| } |
| |
| public void scrollRight() { |
| if (mScroller.isFinished()) { |
| if (mCurrentPage < getChildCount() -1) snapToPage(mCurrentPage + 1); |
| } else { |
| if (mNextPage < getChildCount() -1) snapToPage(mNextPage + 1); |
| } |
| } |
| |
| public int getPageForView(View v) { |
| int result = -1; |
| if (v != null) { |
| ViewParent vp = v.getParent(); |
| int count = getChildCount(); |
| for (int i = 0; i < count; i++) { |
| if (vp == getPageAt(i)) { |
| return i; |
| } |
| } |
| } |
| return result; |
| } |
| |
| public static class SavedState extends BaseSavedState { |
| int currentPage = -1; |
| |
| SavedState(Parcelable superState) { |
| super(superState); |
| } |
| |
| private SavedState(Parcel in) { |
| super(in); |
| currentPage = in.readInt(); |
| } |
| |
| @Override |
| public void writeToParcel(Parcel out, int flags) { |
| super.writeToParcel(out, flags); |
| out.writeInt(currentPage); |
| } |
| |
| public static final Parcelable.Creator<SavedState> CREATOR = |
| new Parcelable.Creator<SavedState>() { |
| public SavedState createFromParcel(Parcel in) { |
| return new SavedState(in); |
| } |
| |
| public SavedState[] newArray(int size) { |
| return new SavedState[size]; |
| } |
| }; |
| } |
| |
| protected View getScrollingIndicator() { |
| return null; |
| } |
| |
| protected boolean isScrollingIndicatorEnabled() { |
| return false; |
| } |
| |
| Runnable hideScrollingIndicatorRunnable = new Runnable() { |
| @Override |
| public void run() { |
| hideScrollingIndicator(false); |
| } |
| }; |
| |
| protected void flashScrollingIndicator(boolean animated) { |
| removeCallbacks(hideScrollingIndicatorRunnable); |
| showScrollingIndicator(!animated); |
| postDelayed(hideScrollingIndicatorRunnable, sScrollIndicatorFlashDuration); |
| } |
| |
| protected void showScrollingIndicator(boolean immediately) { |
| mShouldShowScrollIndicator = true; |
| mShouldShowScrollIndicatorImmediately = true; |
| if (getChildCount() <= 1) return; |
| if (!isScrollingIndicatorEnabled()) return; |
| |
| mShouldShowScrollIndicator = false; |
| getScrollingIndicator(); |
| if (mScrollIndicator != null) { |
| // Fade the indicator in |
| updateScrollingIndicatorPosition(); |
| mScrollIndicator.setVisibility(View.VISIBLE); |
| cancelScrollingIndicatorAnimations(); |
| if (immediately) { |
| mScrollIndicator.setAlpha(1f); |
| } else { |
| mScrollIndicatorAnimator = ObjectAnimator.ofFloat(mScrollIndicator, "alpha", 1f); |
| mScrollIndicatorAnimator.setDuration(sScrollIndicatorFadeInDuration); |
| mScrollIndicatorAnimator.start(); |
| } |
| } |
| } |
| |
| protected void cancelScrollingIndicatorAnimations() { |
| if (mScrollIndicatorAnimator != null) { |
| mScrollIndicatorAnimator.cancel(); |
| } |
| } |
| |
| protected void hideScrollingIndicator(boolean immediately) { |
| if (getChildCount() <= 1) return; |
| if (!isScrollingIndicatorEnabled()) return; |
| |
| getScrollingIndicator(); |
| if (mScrollIndicator != null) { |
| // Fade the indicator out |
| updateScrollingIndicatorPosition(); |
| cancelScrollingIndicatorAnimations(); |
| if (immediately) { |
| mScrollIndicator.setVisibility(View.INVISIBLE); |
| mScrollIndicator.setAlpha(0f); |
| } else { |
| mScrollIndicatorAnimator = ObjectAnimator.ofFloat(mScrollIndicator, "alpha", 0f); |
| mScrollIndicatorAnimator.setDuration(sScrollIndicatorFadeOutDuration); |
| mScrollIndicatorAnimator.addListener(new AnimatorListenerAdapter() { |
| private boolean cancelled = false; |
| @Override |
| public void onAnimationCancel(android.animation.Animator animation) { |
| cancelled = true; |
| } |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| if (!cancelled) { |
| mScrollIndicator.setVisibility(View.INVISIBLE); |
| } |
| } |
| }); |
| mScrollIndicatorAnimator.start(); |
| } |
| } |
| } |
| |
| /** |
| * To be overridden by subclasses to determine whether the scroll indicator should stretch to |
| * fill its space on the track or not. |
| */ |
| protected boolean hasElasticScrollIndicator() { |
| return true; |
| } |
| |
| private void updateScrollingIndicator() { |
| if (getChildCount() <= 1) return; |
| if (!isScrollingIndicatorEnabled()) return; |
| |
| getScrollingIndicator(); |
| if (mScrollIndicator != null) { |
| updateScrollingIndicatorPosition(); |
| } |
| if (mShouldShowScrollIndicator) { |
| showScrollingIndicator(mShouldShowScrollIndicatorImmediately); |
| } |
| } |
| |
| private void updateScrollingIndicatorPosition() { |
| if (!isScrollingIndicatorEnabled()) return; |
| if (mScrollIndicator == null) return; |
| int numPages = getChildCount(); |
| int pageWidth = getViewportWidth(); |
| int lastChildIndex = Math.max(0, getChildCount() - 1); |
| int maxScrollX = getChildOffset(lastChildIndex) - getRelativeChildOffset(lastChildIndex); |
| int trackWidth = pageWidth - mScrollIndicatorPaddingLeft - mScrollIndicatorPaddingRight; |
| int indicatorWidth = mScrollIndicator.getMeasuredWidth() - |
| mScrollIndicator.getPaddingLeft() - mScrollIndicator.getPaddingRight(); |
| |
| float offset = Math.max(0f, Math.min(1f, (float) getScrollX() / maxScrollX)); |
| int indicatorSpace = trackWidth / numPages; |
| int indicatorPos = (int) (offset * (trackWidth - indicatorSpace)) + mScrollIndicatorPaddingLeft; |
| if (hasElasticScrollIndicator()) { |
| if (mScrollIndicator.getMeasuredWidth() != indicatorSpace) { |
| mScrollIndicator.getLayoutParams().width = indicatorSpace; |
| mScrollIndicator.requestLayout(); |
| } |
| } else { |
| int indicatorCenterOffset = indicatorSpace / 2 - indicatorWidth / 2; |
| indicatorPos += indicatorCenterOffset; |
| } |
| mScrollIndicator.setTranslationX(indicatorPos); |
| } |
| |
| // Animate the drag view back to the original position |
| void animateDragViewToOriginalPosition() { |
| if (mDragView != null) { |
| AnimatorSet anim = new AnimatorSet(); |
| anim.setDuration(REORDERING_DROP_REPOSITION_DURATION); |
| anim.playTogether( |
| ObjectAnimator.ofFloat(mDragView, "translationX", 0f), |
| ObjectAnimator.ofFloat(mDragView, "translationY", 0f)); |
| anim.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| onPostReorderingAnimationCompleted(); |
| } |
| }); |
| anim.start(); |
| } |
| } |
| |
| // "Zooms out" the PagedView to reveal more side pages |
| protected boolean zoomOut() { |
| if (mZoomInOutAnim != null && mZoomInOutAnim.isRunning()) { |
| mZoomInOutAnim.cancel(); |
| } |
| |
| if (!(getScaleX() < 1f || getScaleY() < 1f)) { |
| mZoomInOutAnim = new AnimatorSet(); |
| mZoomInOutAnim.setDuration(REORDERING_ZOOM_IN_OUT_DURATION); |
| mZoomInOutAnim.playTogether( |
| ObjectAnimator.ofFloat(this, "scaleX", mMinScale), |
| ObjectAnimator.ofFloat(this, "scaleY", mMinScale)); |
| mZoomInOutAnim.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| // Show the delete drop target |
| if (mDeleteDropTarget != null) { |
| mDeleteDropTarget.setVisibility(View.VISIBLE); |
| mDeleteDropTarget.animate().alpha(1f) |
| .setDuration(REORDERING_DELETE_DROP_TARGET_FADE_DURATION) |
| .setListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| mDeleteDropTarget.setAlpha(0f); |
| } |
| }); |
| } |
| } |
| }); |
| mZoomInOutAnim.start(); |
| return true; |
| } |
| return false; |
| } |
| |
| protected void onStartReordering() { |
| if (AccessibilityManager.getInstance(mContext).isEnabled()) { |
| announceForAccessibility(mContext.getString( |
| R.string.keyguard_accessibility_widget_reorder_start)); |
| } |
| |
| // Set the touch state to reordering (allows snapping to pages, dragging a child, etc.) |
| setTouchState(TOUCH_STATE_REORDERING); |
| mIsReordering = true; |
| |
| // Mark all the non-widget pages as invisible |
| getVisiblePages(mTempVisiblePagesRange); |
| boundByReorderablePages(true, mTempVisiblePagesRange); |
| for (int i = 0; i < getPageCount(); ++i) { |
| if (i < mTempVisiblePagesRange[0] || i > mTempVisiblePagesRange[1]) { |
| getPageAt(i).setAlpha(0f); |
| } |
| } |
| |
| // We must invalidate to trigger a redraw to update the layers such that the drag view |
| // is always drawn on top |
| invalidate(); |
| } |
| |
| private void onPostReorderingAnimationCompleted() { |
| // Trigger the callback when reordering has settled |
| --mPostReorderingPreZoomInRemainingAnimationCount; |
| if (mPostReorderingPreZoomInRunnable != null && |
| mPostReorderingPreZoomInRemainingAnimationCount == 0) { |
| mPostReorderingPreZoomInRunnable.run(); |
| mPostReorderingPreZoomInRunnable = null; |
| } |
| } |
| |
| protected void onEndReordering() { |
| if (AccessibilityManager.getInstance(mContext).isEnabled()) { |
| if (mDeleteString != null) { |
| announceForAccessibility(mDeleteString); |
| mDeleteString = null; |
| } else { |
| announceForAccessibility(mContext.getString( |
| R.string.keyguard_accessibility_widget_reorder_end)); |
| } |
| } |
| mIsReordering = false; |
| |
| // Mark all the non-widget pages as visible again |
| getVisiblePages(mTempVisiblePagesRange); |
| boundByReorderablePages(true, mTempVisiblePagesRange); |
| for (int i = 0; i < getPageCount(); ++i) { |
| if (i < mTempVisiblePagesRange[0] || i > mTempVisiblePagesRange[1]) { |
| getPageAt(i).setAlpha(1f); |
| } |
| } |
| } |
| |
| public boolean startReordering() { |
| int dragViewIndex = getPageNearestToCenterOfScreen(); |
| mTempVisiblePagesRange[0] = 0; |
| mTempVisiblePagesRange[1] = getPageCount() - 1; |
| boundByReorderablePages(true, mTempVisiblePagesRange); |
| |
| // Check if we are within the reordering range |
| if (mTempVisiblePagesRange[0] <= dragViewIndex && |
| dragViewIndex <= mTempVisiblePagesRange[1]) { |
| mReorderingStarted = true; |
| if (zoomOut()) { |
| // Find the drag view under the pointer |
| mDragView = getChildAt(dragViewIndex); |
| |
| onStartReordering(); |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| boolean isReordering(boolean testTouchState) { |
| boolean state = mIsReordering; |
| if (testTouchState) { |
| state &= (mTouchState == TOUCH_STATE_REORDERING); |
| } |
| return state; |
| } |
| void endReordering() { |
| // For simplicity, we call endReordering sometimes even if reordering was never started. |
| // In that case, we don't want to do anything. |
| if (!mReorderingStarted) return; |
| mReorderingStarted = false; |
| |
| // If we haven't flung-to-delete the current child, then we just animate the drag view |
| // back into position |
| final Runnable onCompleteRunnable = new Runnable() { |
| @Override |
| public void run() { |
| onEndReordering(); |
| } |
| }; |
| if (!mDeferringForDelete) { |
| mPostReorderingPreZoomInRunnable = new Runnable() { |
| public void run() { |
| zoomIn(onCompleteRunnable); |
| }; |
| }; |
| |
| mPostReorderingPreZoomInRemainingAnimationCount = |
| NUM_ANIMATIONS_RUNNING_BEFORE_ZOOM_OUT; |
| // Snap to the current page |
| snapToPage(indexOfChild(mDragView), 0); |
| // Animate the drag view back to the front position |
| animateDragViewToOriginalPosition(); |
| } else { |
| // Handled in post-delete-animation-callbacks |
| } |
| } |
| |
| // "Zooms in" the PagedView to highlight the current page |
| protected boolean zoomIn(final Runnable onCompleteRunnable) { |
| if (mZoomInOutAnim != null && mZoomInOutAnim.isRunning()) { |
| mZoomInOutAnim.cancel(); |
| } |
| if (getScaleX() < 1f || getScaleY() < 1f) { |
| mZoomInOutAnim = new AnimatorSet(); |
| mZoomInOutAnim.setDuration(REORDERING_ZOOM_IN_OUT_DURATION); |
| mZoomInOutAnim.playTogether( |
| ObjectAnimator.ofFloat(this, "scaleX", 1f), |
| ObjectAnimator.ofFloat(this, "scaleY", 1f)); |
| mZoomInOutAnim.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationStart(Animator animation) { |
| // Hide the delete drop target |
| if (mDeleteDropTarget != null) { |
| mDeleteDropTarget.animate().alpha(0f) |
| .setDuration(REORDERING_DELETE_DROP_TARGET_FADE_DURATION) |
| .setListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mDeleteDropTarget.setVisibility(View.GONE); |
| } |
| }); |
| } |
| } |
| @Override |
| public void onAnimationCancel(Animator animation) { |
| mDragView = null; |
| } |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mDragView = null; |
| if (onCompleteRunnable != null) { |
| onCompleteRunnable.run(); |
| } |
| } |
| }); |
| mZoomInOutAnim.start(); |
| return true; |
| } else { |
| if (onCompleteRunnable != null) { |
| onCompleteRunnable.run(); |
| } |
| } |
| return false; |
| } |
| |
| /* |
| * Flinging to delete - IN PROGRESS |
| */ |
| private PointF isFlingingToDelete() { |
| ViewConfiguration config = ViewConfiguration.get(getContext()); |
| mVelocityTracker.computeCurrentVelocity(1000, config.getScaledMaximumFlingVelocity()); |
| |
| if (mVelocityTracker.getYVelocity() < mFlingToDeleteThresholdVelocity) { |
| // Do a quick dot product test to ensure that we are flinging upwards |
| PointF vel = new PointF(mVelocityTracker.getXVelocity(), |
| mVelocityTracker.getYVelocity()); |
| PointF upVec = new PointF(0f, -1f); |
| float theta = (float) Math.acos(((vel.x * upVec.x) + (vel.y * upVec.y)) / |
| (vel.length() * upVec.length())); |
| if (theta <= Math.toRadians(FLING_TO_DELETE_MAX_FLING_DEGREES)) { |
| return vel; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Creates an animation from the current drag view along its current velocity vector. |
| * For this animation, the alpha runs for a fixed duration and we update the position |
| * progressively. |
| */ |
| private static class FlingAlongVectorAnimatorUpdateListener implements AnimatorUpdateListener { |
| private View mDragView; |
| private PointF mVelocity; |
| private Rect mFrom; |
| private long mPrevTime; |
| private float mFriction; |
| |
| private final TimeInterpolator mAlphaInterpolator = new DecelerateInterpolator(0.75f); |
| |
| public FlingAlongVectorAnimatorUpdateListener(View dragView, PointF vel, Rect from, |
| long startTime, float friction) { |
| mDragView = dragView; |
| mVelocity = vel; |
| mFrom = from; |
| mPrevTime = startTime; |
| mFriction = 1f - (mDragView.getResources().getDisplayMetrics().density * friction); |
| } |
| |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| float t = ((Float) animation.getAnimatedValue()).floatValue(); |
| long curTime = AnimationUtils.currentAnimationTimeMillis(); |
| |
| mFrom.left += (mVelocity.x * (curTime - mPrevTime) / 1000f); |
| mFrom.top += (mVelocity.y * (curTime - mPrevTime) / 1000f); |
| |
| mDragView.setTranslationX(mFrom.left); |
| mDragView.setTranslationY(mFrom.top); |
| mDragView.setAlpha(1f - mAlphaInterpolator.getInterpolation(t)); |
| |
| mVelocity.x *= mFriction; |
| mVelocity.y *= mFriction; |
| mPrevTime = curTime; |
| } |
| }; |
| |
| private Runnable createPostDeleteAnimationRunnable(final View dragView) { |
| return new Runnable() { |
| @Override |
| public void run() { |
| int dragViewIndex = indexOfChild(dragView); |
| |
| // For each of the pages around the drag view, animate them from the previous |
| // position to the new position in the layout (as a result of the drag view moving |
| // in the layout) |
| // NOTE: We can make an assumption here because we have side-bound pages that we |
| // will always have pages to animate in from the left |
| getVisiblePages(mTempVisiblePagesRange); |
| boundByReorderablePages(true, mTempVisiblePagesRange); |
| boolean isLastWidgetPage = (mTempVisiblePagesRange[0] == mTempVisiblePagesRange[1]); |
| boolean slideFromLeft = (isLastWidgetPage || |
| dragViewIndex > mTempVisiblePagesRange[0]); |
| |
| // Setup the scroll to the correct page before we swap the views |
| if (slideFromLeft) { |
| snapToPageImmediately(dragViewIndex - 1); |
| } |
| |
| int firstIndex = (isLastWidgetPage ? 0 : mTempVisiblePagesRange[0]); |
| int lastIndex = Math.min(mTempVisiblePagesRange[1], getPageCount() - 1); |
| int lowerIndex = (slideFromLeft ? firstIndex : dragViewIndex + 1 ); |
| int upperIndex = (slideFromLeft ? dragViewIndex - 1 : lastIndex); |
| ArrayList<Animator> animations = new ArrayList<Animator>(); |
| for (int i = lowerIndex; i <= upperIndex; ++i) { |
| View v = getChildAt(i); |
| // dragViewIndex < pageUnderPointIndex, so after we remove the |
| // drag view all subsequent views to pageUnderPointIndex will |
| // shift down. |
| int oldX = 0; |
| int newX = 0; |
| if (slideFromLeft) { |
| if (i == 0) { |
| // Simulate the page being offscreen with the page spacing |
| oldX = getViewportOffsetX() + getChildOffset(i) - getChildWidth(i) |
| - mPageSpacing; |
| } else { |
| oldX = getViewportOffsetX() + getChildOffset(i - 1); |
| } |
| newX = getViewportOffsetX() + getChildOffset(i); |
| } else { |
| oldX = getChildOffset(i) - getChildOffset(i - 1); |
| newX = 0; |
| } |
| |
| // Animate the view translation from its old position to its new |
| // position |
| AnimatorSet anim = (AnimatorSet) v.getTag(); |
| if (anim != null) { |
| anim.cancel(); |
| } |
| |
| // Note: Hacky, but we want to skip any optimizations to not draw completely |
| // hidden views |
| v.setAlpha(Math.max(v.getAlpha(), 0.01f)); |
| v.setTranslationX(oldX - newX); |
| anim = new AnimatorSet(); |
| anim.playTogether( |
| ObjectAnimator.ofFloat(v, "translationX", 0f), |
| ObjectAnimator.ofFloat(v, "alpha", 1f)); |
| animations.add(anim); |
| v.setTag(anim); |
| } |
| |
| AnimatorSet slideAnimations = new AnimatorSet(); |
| slideAnimations.playTogether(animations); |
| slideAnimations.setDuration(DELETE_SLIDE_IN_SIDE_PAGE_DURATION); |
| slideAnimations.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| final Runnable onCompleteRunnable = new Runnable() { |
| @Override |
| public void run() { |
| mDeferringForDelete = false; |
| onEndReordering(); |
| onRemoveViewAnimationCompleted(); |
| } |
| }; |
| zoomIn(onCompleteRunnable); |
| } |
| }); |
| slideAnimations.start(); |
| |
| removeView(dragView); |
| onRemoveView(dragView, true); |
| } |
| }; |
| } |
| |
| public void onFlingToDelete(PointF vel) { |
| final long startTime = AnimationUtils.currentAnimationTimeMillis(); |
| |
| // NOTE: Because it takes time for the first frame of animation to actually be |
| // called and we expect the animation to be a continuation of the fling, we have |
| // to account for the time that has elapsed since the fling finished. And since |
| // we don't have a startDelay, we will always get call to update when we call |
| // start() (which we want to ignore). |
| final TimeInterpolator tInterpolator = new TimeInterpolator() { |
| private int mCount = -1; |
| private long mStartTime; |
| private float mOffset; |
| /* Anonymous inner class ctor */ { |
| mStartTime = startTime; |
| } |
| |
| @Override |
| public float getInterpolation(float t) { |
| if (mCount < 0) { |
| mCount++; |
| } else if (mCount == 0) { |
| mOffset = Math.min(0.5f, (float) (AnimationUtils.currentAnimationTimeMillis() - |
| mStartTime) / FLING_TO_DELETE_FADE_OUT_DURATION); |
| mCount++; |
| } |
| return Math.min(1f, mOffset + t); |
| } |
| }; |
| |
| final Rect from = new Rect(); |
| final View dragView = mDragView; |
| from.left = (int) dragView.getTranslationX(); |
| from.top = (int) dragView.getTranslationY(); |
| AnimatorUpdateListener updateCb = new FlingAlongVectorAnimatorUpdateListener(dragView, vel, |
| from, startTime, FLING_TO_DELETE_FRICTION); |
| |
| mDeleteString = getContext().getResources() |
| .getString(R.string.keyguard_accessibility_widget_deleted, |
| mDragView.getContentDescription()); |
| final Runnable onAnimationEndRunnable = createPostDeleteAnimationRunnable(dragView); |
| |
| // Create and start the animation |
| ValueAnimator mDropAnim = new ValueAnimator(); |
| mDropAnim.setInterpolator(tInterpolator); |
| mDropAnim.setDuration(FLING_TO_DELETE_FADE_OUT_DURATION); |
| mDropAnim.setFloatValues(0f, 1f); |
| mDropAnim.addUpdateListener(updateCb); |
| mDropAnim.addListener(new AnimatorListenerAdapter() { |
| public void onAnimationEnd(Animator animation) { |
| onAnimationEndRunnable.run(); |
| } |
| }); |
| mDropAnim.start(); |
| mDeferringForDelete = true; |
| } |
| |
| /* Drag to delete */ |
| private boolean isHoveringOverDeleteDropTarget(int x, int y) { |
| if (mDeleteDropTarget != null) { |
| mAltTmpRect.set(0, 0, 0, 0); |
| View parent = (View) mDeleteDropTarget.getParent(); |
| if (parent != null) { |
| parent.getGlobalVisibleRect(mAltTmpRect); |
| } |
| mDeleteDropTarget.getGlobalVisibleRect(mTmpRect); |
| mTmpRect.offset(-mAltTmpRect.left, -mAltTmpRect.top); |
| return mTmpRect.contains(x, y); |
| } |
| return false; |
| } |
| |
| protected void setPageHoveringOverDeleteDropTarget(int viewIndex, boolean isHovering) {} |
| |
| private void onDropToDelete() { |
| final View dragView = mDragView; |
| |
| final float toScale = 0f; |
| final float toAlpha = 0f; |
| |
| // Create and start the complex animation |
| ArrayList<Animator> animations = new ArrayList<Animator>(); |
| AnimatorSet motionAnim = new AnimatorSet(); |
| motionAnim.setInterpolator(new DecelerateInterpolator(2)); |
| motionAnim.playTogether( |
| ObjectAnimator.ofFloat(dragView, "scaleX", toScale), |
| ObjectAnimator.ofFloat(dragView, "scaleY", toScale)); |
| animations.add(motionAnim); |
| |
| AnimatorSet alphaAnim = new AnimatorSet(); |
| alphaAnim.setInterpolator(new LinearInterpolator()); |
| alphaAnim.playTogether( |
| ObjectAnimator.ofFloat(dragView, "alpha", toAlpha)); |
| animations.add(alphaAnim); |
| |
| mDeleteString = getContext().getResources() |
| .getString(R.string.keyguard_accessibility_widget_deleted, |
| mDragView.getContentDescription()); |
| final Runnable onAnimationEndRunnable = createPostDeleteAnimationRunnable(dragView); |
| |
| AnimatorSet anim = new AnimatorSet(); |
| anim.playTogether(animations); |
| anim.setDuration(DRAG_TO_DELETE_FADE_OUT_DURATION); |
| anim.addListener(new AnimatorListenerAdapter() { |
| public void onAnimationEnd(Animator animation) { |
| onAnimationEndRunnable.run(); |
| } |
| }); |
| anim.start(); |
| |
| mDeferringForDelete = true; |
| } |
| |
| /* Accessibility */ |
| @Override |
| public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) { |
| super.onInitializeAccessibilityNodeInfo(info); |
| info.setScrollable(getPageCount() > 1); |
| if (getCurrentPage() < getPageCount() - 1) { |
| info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD); |
| } |
| if (getCurrentPage() > 0) { |
| info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD); |
| } |
| } |
| |
| @Override |
| public void onInitializeAccessibilityEvent(AccessibilityEvent event) { |
| super.onInitializeAccessibilityEvent(event); |
| event.setScrollable(true); |
| if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_SCROLLED) { |
| event.setFromIndex(mCurrentPage); |
| event.setToIndex(mCurrentPage); |
| event.setItemCount(getChildCount()); |
| } |
| } |
| |
| @Override |
| public boolean performAccessibilityAction(int action, Bundle arguments) { |
| if (super.performAccessibilityAction(action, arguments)) { |
| return true; |
| } |
| switch (action) { |
| case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: { |
| if (getCurrentPage() < getPageCount() - 1) { |
| scrollRight(); |
| return true; |
| } |
| } break; |
| case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: { |
| if (getCurrentPage() > 0) { |
| scrollLeft(); |
| return true; |
| } |
| } break; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean onHoverEvent(android.view.MotionEvent event) { |
| return true; |
| } |
| |
| void beginCameraEvent() { |
| mIsCameraEvent = true; |
| } |
| |
| void endCameraEvent() { |
| mIsCameraEvent = false; |
| } |
| |
| AnimatorListenerAdapter mOnScreenAnimationListener = new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mWarpAnimation = null; |
| if (mTouchState != TOUCH_STATE_SCROLLING && mTouchState != TOUCH_STATE_READY) { |
| animateWarpPageOffScreen("onScreen end", true); |
| } |
| } |
| }; |
| |
| AnimatorListenerAdapter mOffScreenAnimationListener = new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mWarpAnimation = null; |
| mWarpPageExposed = false; |
| } |
| }; |
| |
| private void cancelWarpAnimation(String msg, boolean abortAnimation) { |
| if (DEBUG_WARP) Log.v(TAG, "cancelWarpAnimation(" + msg + ",abort=" + abortAnimation + ")"); |
| if (abortAnimation) { |
| // We're done with the animation and moving to a new page. Let the scroller |
| // take over the animation. |
| KeyguardWidgetFrame v = (KeyguardWidgetFrame) getPageAt(mPageWarpIndex); |
| v.animate().cancel(); |
| // Make the scroll amount match the current warp position. |
| scrollBy(Math.round(-v.getTranslationX()), 0); |
| v.setTranslationX(0); |
| } else { |
| animateWarpPageOffScreen("canceled", true); |
| } |
| } |
| |
| private boolean isAnimatingWarpPage() { |
| return mWarpAnimation != null; |
| } |
| |
| private void animateWarpPageOnScreen(String reason) { |
| if (DEBUG_WARP) Log.v(TAG, "animateWarpPageOnScreen(" + reason + ")"); |
| if (isWarping() && !mWarpPageExposed) { |
| mWarpPageExposed = true; |
| dispatchOnPageBeginWarp(); |
| KeyguardWidgetFrame v = (KeyguardWidgetFrame) getPageAt(mPageWarpIndex); |
| if (DEBUG_WARP) Log.v(TAG, "moving page on screen: Tx=" + v.getTranslationX()); |
| DecelerateInterpolator interp = new DecelerateInterpolator(1.5f); |
| mWarpAnimation = v.animate(); |
| mWarpAnimation.translationX(mWarpPeekAmount) |
| .setInterpolator(interp) |
| .setDuration(WARP_PEEK_ANIMATION_DURATION) |
| .setListener(mOnScreenAnimationListener); |
| } |
| } |
| |
| private void animateWarpPageOffScreen(String reason, boolean animate) { |
| if (DEBUG_WARP) Log.v(TAG, "animateWarpPageOffScreen(" + reason + " anim:" + animate + ")"); |
| if (isWarping()) { |
| dispatchOnPageEndWarp(); |
| KeyguardWidgetFrame v = (KeyguardWidgetFrame) getPageAt(mPageWarpIndex); |
| if (DEBUG_WARP) Log.v(TAG, "moving page off screen: Tx=" + v.getTranslationX()); |
| AccelerateInterpolator interp = new AccelerateInterpolator(1.5f); |
| v.animate().translationX(0.0f) |
| .setInterpolator(interp) |
| .setDuration(animate ? WARP_PEEK_ANIMATION_DURATION : 0) |
| .setListener(mOffScreenAnimationListener); |
| } else { |
| if (DEBUG_WARP) Log.e(TAG, "animateWarpPageOffScreen(): not warping", new Exception()); |
| } |
| } |
| |
| /** |
| * Swaps the position of the views by setting the left and right edges appropriately. |
| */ |
| void swapPages(int indexA, int indexB) { |
| View viewA = getPageAt(indexA); |
| View viewB = getPageAt(indexB); |
| if (viewA != viewB && viewA != null && viewB != null) { |
| int deltaX = viewA.getLeft() - viewB.getLeft(); |
| viewA.offsetLeftAndRight(-deltaX); |
| viewB.offsetLeftAndRight(deltaX); |
| } |
| } |
| |
| public void startPageWarp(int pageIndex) { |
| if (DEBUG_WARP) Log.v(TAG, "START WARP"); |
| if (pageIndex != mCurrentPage + 1) { |
| mPageSwapIndex = mCurrentPage + 1; |
| } |
| mPageWarpIndex = pageIndex; |
| } |
| |
| protected int getPageWarpIndex() { |
| return mPageWarpIndex; |
| } |
| |
| public void stopPageWarp() { |
| if (DEBUG_WARP) Log.v(TAG, "END WARP"); |
| // mPageSwapIndex is reset in snapToPage() after the scroll animation completes |
| } |
| |
| public void onPageBeginWarp() { |
| |
| } |
| |
| public void onPageEndWarp() { |
| |
| } |
| |
| } |