blob: 9f6efb37019f53d77af07a6455d570915e69bb1f [file] [log] [blame]
Winson Chung321e9ee2010-08-09 13:37:56 -07001/*
Adam Cohen7d30a372013-07-01 17:03:59 -07002 * Copyright (C) 2012 The Android Open Source Project
Winson Chung321e9ee2010-08-09 13:37:56 -07003 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Daniel Sandler325dc232013-06-05 22:57:57 -040017package com.android.launcher3;
Winson Chung321e9ee2010-08-09 13:37:56 -070018
Winson Chung228a0fa2011-01-26 22:14:13 -080019import android.animation.Animator;
Winson Chung228a0fa2011-01-26 22:14:13 -080020import android.animation.AnimatorListenerAdapter;
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -070021import android.animation.LayoutTransition;
Adam Cohen7d30a372013-07-01 17:03:59 -070022import android.animation.ObjectAnimator;
23import android.animation.TimeInterpolator;
Sunny Goyalcf25b522015-07-09 00:01:18 -070024import android.annotation.SuppressLint;
Winson Chung321e9ee2010-08-09 13:37:56 -070025import android.content.Context;
Adam Cohen9c4949e2010-10-05 12:27:22 -070026import android.content.res.TypedArray;
Adam Cohen7d30a372013-07-01 17:03:59 -070027import android.graphics.Matrix;
Winson Chung321e9ee2010-08-09 13:37:56 -070028import android.graphics.Rect;
Svetoslav Ganov08055f62012-05-15 11:06:36 -070029import android.os.Bundle;
Winson Chung321e9ee2010-08-09 13:37:56 -070030import android.os.Parcel;
31import android.os.Parcelable;
32import android.util.AttributeSet;
Winson Chung785d2eb2011-04-14 16:08:02 -070033import android.util.Log;
Winson Chung185d7162011-02-28 13:47:29 -080034import android.view.InputDevice;
35import android.view.KeyEvent;
Winson Chung321e9ee2010-08-09 13:37:56 -070036import android.view.MotionEvent;
37import android.view.VelocityTracker;
38import android.view.View;
39import android.view.ViewConfiguration;
Sunny Goyal4ffec482016-02-09 11:28:52 -080040import android.view.ViewDebug;
Winson Chung321e9ee2010-08-09 13:37:56 -070041import android.view.ViewGroup;
42import android.view.ViewParent;
Winson Chung6a0f57d2011-06-29 20:10:49 -070043import android.view.accessibility.AccessibilityEvent;
Winson Chungc27d1bb2011-09-29 12:07:42 -070044import android.view.accessibility.AccessibilityManager;
Winson Chung6a0f57d2011-06-29 20:10:49 -070045import android.view.accessibility.AccessibilityNodeInfo;
Adam Cohene0f66b52010-11-23 15:06:07 -080046import android.view.animation.Interpolator;
Tony Wickhamf549dab2016-05-16 09:54:06 -070047
Sunny Goyal5bc6b6f2017-10-26 15:36:10 -070048import com.android.launcher3.anim.Interpolators;
Sunny Goyal9e76f682017-02-13 12:13:43 -080049import com.android.launcher3.anim.PropertyListBuilder;
Tony Wickhamf549dab2016-05-16 09:54:06 -070050import com.android.launcher3.pageindicators.PageIndicator;
Sunny Goyalb72d8b22017-07-14 00:02:27 -070051import com.android.launcher3.touch.OverScroll;
Adam Cohen091440a2015-03-18 14:16:05 -070052import com.android.launcher3.util.Thunk;
Tony Wickhamf549dab2016-05-16 09:54:06 -070053
Winson Chung6a0f57d2011-06-29 20:10:49 -070054import java.util.ArrayList;
55
Winson Chung321e9ee2010-08-09 13:37:56 -070056/**
57 * An abstraction of the original Workspace which supports browsing through a
Michael Jurka0142d492010-08-25 17:46:15 -070058 * sequential list of "pages"
Winson Chung321e9ee2010-08-09 13:37:56 -070059 */
Michael Jurka8b805b12012-04-18 14:23:14 -070060public abstract class PagedView extends ViewGroup implements ViewGroup.OnHierarchyChangeListener {
Winson Chung321e9ee2010-08-09 13:37:56 -070061 private static final String TAG = "PagedView";
Winson Chung785d2eb2011-04-14 16:08:02 -070062 private static final boolean DEBUG = false;
Michael Jurka0142d492010-08-25 17:46:15 -070063 protected static final int INVALID_PAGE = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -070064
Winson Chung86f77532010-08-24 11:08:22 -070065 // the min drag distance for a fling to register, to prevent random page shifts
Winson Chung9cfd25f2010-10-24 16:09:28 -070066 private static final int MIN_LENGTH_FOR_FLING = 25;
Winson Chung321e9ee2010-08-09 13:37:56 -070067
Vadim Tryshevfedca432015-08-19 17:55:02 -070068 public static final int PAGE_SNAP_ANIMATION_DURATION = 750;
Winson Chungf0c6ae02012-03-21 16:10:31 -070069 protected static final int SLOW_PAGE_SNAP_ANIMATION_DURATION = 950;
Winson Chung321e9ee2010-08-09 13:37:56 -070070
Sunny Goyalb72d8b22017-07-14 00:02:27 -070071 // OverScroll constants
Adam Cohen8d769d62017-06-23 17:27:38 -070072 private final static int OVERSCROLL_PAGE_SNAP_ANIMATION_DURATION = 270;
Adam Cohen8d769d62017-06-23 17:27:38 -070073
Adam Cohenb64cb5a2011-02-15 13:53:42 -080074 private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.33f;
Adam Cohen00481b32011-11-18 12:03:48 -080075 // The page is moved more than halfway, automatically move to the next page on touch up.
76 private static final float SIGNIFICANT_MOVE_THRESHOLD = 0.4f;
Adam Cohen68d73932010-11-15 10:50:58 -080077
Sunny Goyal8e2133b2015-05-06 13:39:07 -070078 private static final float MAX_SCROLL_PROGRESS = 1.0f;
79
Adam Cohen265b9a62011-12-07 14:37:18 -080080 // The following constants need to be scaled based on density. The scaled versions will be
81 // assigned to the corresponding member variables below.
82 private static final int FLING_THRESHOLD_VELOCITY = 500;
83 private static final int MIN_SNAP_VELOCITY = 1500;
84 private static final int MIN_FLING_VELOCITY = 250;
85
Adam Cohen21cd0022013-10-09 18:57:02 -070086 public static final int INVALID_RESTORE_PAGE = -1001;
87
Adam Cohenf358a4b2013-07-23 16:47:31 -070088 private boolean mFreeScroll = false;
Tony Wickham1c9bf6a2017-11-17 10:25:27 -080089 private boolean mSettleOnPageInFreeScroll = false;
Adam Cohenf358a4b2013-07-23 16:47:31 -070090
Adam Cohen265b9a62011-12-07 14:37:18 -080091 protected int mFlingThresholdVelocity;
92 protected int mMinFlingVelocity;
93 protected int mMinSnapVelocity;
Michael Jurka0142d492010-08-25 17:46:15 -070094
Michael Jurka0142d492010-08-25 17:46:15 -070095 protected boolean mFirstLayout = true;
96
Sunny Goyal4ffec482016-02-09 11:28:52 -080097 @ViewDebug.ExportedProperty(category = "launcher")
Michael Jurka0142d492010-08-25 17:46:15 -070098 protected int mCurrentPage;
Sunny Goyalcf25b522015-07-09 00:01:18 -070099 private int mChildCountOnLastLayout;
Adam Cohene61a9a22013-06-11 15:45:31 -0700100
Sunny Goyal4ffec482016-02-09 11:28:52 -0800101 @ViewDebug.ExportedProperty(category = "launcher")
Michael Jurka0142d492010-08-25 17:46:15 -0700102 protected int mNextPage = INVALID_PAGE;
Sunny Goyalc86df472016-02-25 09:19:38 -0800103 protected int mMaxScrollX;
Adam Cohenf9618852013-11-08 06:45:03 -0800104 protected LauncherScroller mScroller;
105 private Interpolator mDefaultInterpolator;
Winson Chung321e9ee2010-08-09 13:37:56 -0700106 private VelocityTracker mVelocityTracker;
Adam Cohen091440a2015-03-18 14:16:05 -0700107 @Thunk int mPageSpacing = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -0700108
Adam Cohen7d30a372013-07-01 17:03:59 -0700109 private float mParentDownMotionX;
110 private float mParentDownMotionY;
Winson Chung321e9ee2010-08-09 13:37:56 -0700111 private float mDownMotionX;
Adam Cohen7d30a372013-07-01 17:03:59 -0700112 private float mDownMotionY;
113 private float mDownScrollX;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700114 private float mDragViewBaselineLeft;
Sunny Goyalcf25b522015-07-09 00:01:18 -0700115 private float mLastMotionX;
116 private float mLastMotionXRemainder;
117 private float mLastMotionY;
118 private float mTotalMotionX;
Adam Cohenedb40762013-07-18 16:45:45 -0700119
Adam Cohendbdff6b2013-09-18 19:09:15 -0700120 private boolean mCancelTap;
121
Adam Cohenedb40762013-07-18 16:45:45 -0700122 private int[] mPageScrolls;
Winson Chung321e9ee2010-08-09 13:37:56 -0700123
Michael Jurka0142d492010-08-25 17:46:15 -0700124 protected final static int TOUCH_STATE_REST = 0;
125 protected final static int TOUCH_STATE_SCROLLING = 1;
126 protected final static int TOUCH_STATE_PREV_PAGE = 2;
127 protected final static int TOUCH_STATE_NEXT_PAGE = 3;
Adam Cohen7d30a372013-07-01 17:03:59 -0700128 protected final static int TOUCH_STATE_REORDERING = 4;
129
Michael Jurka0142d492010-08-25 17:46:15 -0700130 protected int mTouchState = TOUCH_STATE_REST;
Adam Cohencae7f572013-11-04 14:42:52 -0800131
Michael Jurka0142d492010-08-25 17:46:15 -0700132 protected OnLongClickListener mLongClickListener;
Winson Chung321e9ee2010-08-09 13:37:56 -0700133
Michael Jurka7426c422010-11-11 15:23:47 -0800134 protected int mTouchSlop;
Winson Chung321e9ee2010-08-09 13:37:56 -0700135 private int mMaximumVelocity;
Adam Cohen68d73932010-11-15 10:50:58 -0800136 protected boolean mAllowOverScroll = true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700137
Michael Jurka5f1c5092010-09-03 14:15:02 -0700138 protected static final int INVALID_POINTER = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -0700139
Michael Jurka5f1c5092010-09-03 14:15:02 -0700140 protected int mActivePointerId = INVALID_POINTER;
Winson Chung321e9ee2010-08-09 13:37:56 -0700141
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700142 protected boolean mIsPageInTransition = false;
Patrick Dubroy1262e362010-10-06 15:49:50 -0700143
Sunny Goyal061380a2016-02-29 15:15:03 -0800144 protected boolean mWasInOverscroll = false;
Adam Cohenc2d6e892014-10-16 09:49:24 -0700145
Adam Cohen8d769d62017-06-23 17:27:38 -0700146 // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. Otherwise
147 // it is equal to the scaled overscroll position. We use a separate value so as to prevent
148 // the screens from continuing to translate beyond the normal bounds.
149 protected int mOverScrollX;
150
151 protected int mUnboundedScrollX;
152
Winson Chungd2be3812013-07-16 11:11:32 -0700153 // Page Indicator
Adam Cohen091440a2015-03-18 14:16:05 -0700154 @Thunk int mPageIndicatorViewId;
Sunny Goyald0a6ae72016-06-16 12:29:03 -0700155 protected PageIndicator mPageIndicator;
Adam Cohen7d30a372013-07-01 17:03:59 -0700156 // The viewport whether the pages are to be contained (the actual view may be larger than the
157 // viewport)
Sunny Goyal4ffec482016-02-09 11:28:52 -0800158 @ViewDebug.ExportedProperty(category = "launcher")
Adam Cohen7d30a372013-07-01 17:03:59 -0700159 private Rect mViewport = new Rect();
160
161 // Reordering
162 // We use the min scale to determine how much to expand the actually PagedView measured
163 // dimensions such that when we are zoomed out, the view is not clipped
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700164 private static int REORDERING_DROP_REPOSITION_DURATION = 200;
Sunny Goyal316490e2015-06-02 09:38:28 -0700165 @Thunk static int REORDERING_REORDER_REPOSITION_DURATION = 300;
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700166 private static int REORDERING_SIDE_PAGE_HOVER_TIMEOUT = 80;
167
Sunny Goyalcf25b522015-07-09 00:01:18 -0700168 @Thunk View mDragView;
Adam Cohen7d30a372013-07-01 17:03:59 -0700169 private Runnable mSidePageHoverRunnable;
Adam Cohen091440a2015-03-18 14:16:05 -0700170 @Thunk int mSidePageHoverIndex = -1;
Adam Cohen7d30a372013-07-01 17:03:59 -0700171 // This variable's scope is only for the duration of startReordering() and endReordering()
172 private boolean mReorderingStarted = false;
173 // This variable's scope is for the duration of startReordering() and after the zoomIn()
174 // animation after endReordering()
175 private boolean mIsReordering;
176 // The runnable that settles the page after snapToPage and animateDragViewToOriginalPosition
Sunny Goyalcf25b522015-07-09 00:01:18 -0700177 private static final int NUM_ANIMATIONS_RUNNING_BEFORE_ZOOM_OUT = 2;
Adam Cohen7d30a372013-07-01 17:03:59 -0700178 private int mPostReorderingPreZoomInRemainingAnimationCount;
179 private Runnable mPostReorderingPreZoomInRunnable;
180
Adam Cohen7d30a372013-07-01 17:03:59 -0700181 // Convenience/caching
Sunny Goyal106bf642015-07-16 12:18:06 -0700182 private static final Matrix sTmpInvMatrix = new Matrix();
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700183 private static final float[] sTmpPoint = new float[2];
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700184 private static final Rect sTmpRect = new Rect();
Winson Chungb44b5242011-06-13 11:32:14 -0700185
John Spurlock77e1f472013-09-11 10:09:51 -0400186 protected final Rect mInsets = new Rect();
Sunny Goyal70660032015-05-14 00:07:08 -0700187 protected final boolean mIsRtl;
John Spurlock77e1f472013-09-11 10:09:51 -0400188
Winson Chung321e9ee2010-08-09 13:37:56 -0700189 public PagedView(Context context) {
190 this(context, null);
191 }
192
193 public PagedView(Context context, AttributeSet attrs) {
194 this(context, attrs, 0);
195 }
196
197 public PagedView(Context context, AttributeSet attrs, int defStyle) {
198 super(context, attrs, defStyle);
Winson Chungc9ca2982013-07-19 12:07:38 -0700199
Adam Cohen9c4949e2010-10-05 12:27:22 -0700200 TypedArray a = context.obtainStyledAttributes(attrs,
201 R.styleable.PagedView, defStyle, 0);
Winson Chungd2be3812013-07-16 11:11:32 -0700202 mPageIndicatorViewId = a.getResourceId(R.styleable.PagedView_pageIndicator, -1);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700203 a.recycle();
204
Winson Chung321e9ee2010-08-09 13:37:56 -0700205 setHapticFeedbackEnabled(false);
Sunny Goyal70660032015-05-14 00:07:08 -0700206 mIsRtl = Utilities.isRtl(getResources());
Michael Jurka0142d492010-08-25 17:46:15 -0700207 init();
Winson Chung321e9ee2010-08-09 13:37:56 -0700208 }
209
210 /**
211 * Initializes various states for this workspace.
212 */
Michael Jurka0142d492010-08-25 17:46:15 -0700213 protected void init() {
Adam Cohenf9618852013-11-08 06:45:03 -0800214 mScroller = new LauncherScroller(getContext());
Sunny Goyal5bc6b6f2017-10-26 15:36:10 -0700215 setDefaultInterpolator(Interpolators.SCROLL);
Winson Chung86f77532010-08-24 11:08:22 -0700216 mCurrentPage = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -0700217
218 final ViewConfiguration configuration = ViewConfiguration.get(getContext());
Adam Cohen7d30a372013-07-01 17:03:59 -0700219 mTouchSlop = configuration.getScaledPagingTouchSlop();
Winson Chung321e9ee2010-08-09 13:37:56 -0700220 mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
Adam Cohen265b9a62011-12-07 14:37:18 -0800221
Sunny Goyalcf25b522015-07-09 00:01:18 -0700222 float density = getResources().getDisplayMetrics().density;
223 mFlingThresholdVelocity = (int) (FLING_THRESHOLD_VELOCITY * density);
224 mMinFlingVelocity = (int) (MIN_FLING_VELOCITY * density);
225 mMinSnapVelocity = (int) (MIN_SNAP_VELOCITY * density);
Michael Jurka8b805b12012-04-18 14:23:14 -0700226 setOnHierarchyChangeListener(this);
Sunny Goyal4d113a52015-05-27 10:05:28 -0700227 setWillNotDraw(false);
Winson Chung321e9ee2010-08-09 13:37:56 -0700228 }
229
Adam Cohenf9618852013-11-08 06:45:03 -0800230 protected void setDefaultInterpolator(Interpolator interpolator) {
231 mDefaultInterpolator = interpolator;
232 mScroller.setInterpolator(mDefaultInterpolator);
233 }
234
Sunny Goyald0a6ae72016-06-16 12:29:03 -0700235 public void initParentViews(View parent) {
236 if (mPageIndicatorViewId > -1) {
237 mPageIndicator = (PageIndicator) parent.findViewById(mPageIndicatorViewId);
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700238 mPageIndicator.setMarkersCount(getChildCount());
Sunny Goyal53fe1f22016-07-08 08:47:07 -0700239 mPageIndicator.setContentDescription(getPageIndicatorDescription());
Winson Chungd2be3812013-07-16 11:11:32 -0700240 }
241 }
242
Adam Cohen7d30a372013-07-01 17:03:59 -0700243 // Convenience methods to map points from self to parent and vice versa
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700244 private float[] mapPointFromViewToParent(View v, float x, float y) {
245 sTmpPoint[0] = x;
246 sTmpPoint[1] = y;
247 v.getMatrix().mapPoints(sTmpPoint);
248 sTmpPoint[0] += v.getLeft();
249 sTmpPoint[1] += v.getTop();
250 return sTmpPoint;
Adam Cohen7d30a372013-07-01 17:03:59 -0700251 }
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700252 private float[] mapPointFromParentToView(View v, float x, float y) {
253 sTmpPoint[0] = x - v.getLeft();
254 sTmpPoint[1] = y - v.getTop();
255 v.getMatrix().invert(sTmpInvMatrix);
256 sTmpInvMatrix.mapPoints(sTmpPoint);
257 return sTmpPoint;
Adam Cohen7d30a372013-07-01 17:03:59 -0700258 }
259
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700260 private void updateDragViewTranslationDuringDrag() {
Adam Cohenf358a4b2013-07-23 16:47:31 -0700261 if (mDragView != null) {
262 float x = (mLastMotionX - mDownMotionX) + (getScrollX() - mDownScrollX) +
263 (mDragViewBaselineLeft - mDragView.getLeft());
264 float y = mLastMotionY - mDownMotionY;
265 mDragView.setTranslationX(x);
266 mDragView.setTranslationY(y);
Adam Cohen7d30a372013-07-01 17:03:59 -0700267
Adam Cohenf358a4b2013-07-23 16:47:31 -0700268 if (DEBUG) Log.d(TAG, "PagedView.updateDragViewTranslationDuringDrag(): "
269 + x + ", " + y);
270 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700271 }
272
Adam Cohen7d30a372013-07-01 17:03:59 -0700273 @Override
274 public void setScaleX(float scaleX) {
275 super.setScaleX(scaleX);
276 if (isReordering(true)) {
277 float[] p = mapPointFromParentToView(this, mParentDownMotionX, mParentDownMotionY);
278 mLastMotionX = p[0];
279 mLastMotionY = p[1];
280 updateDragViewTranslationDuringDrag();
281 }
282 }
283
284 // Convenience methods to get the actual width/height of the PagedView (since it is measured
285 // to be larger to account for the minimum possible scale)
286 int getViewportWidth() {
287 return mViewport.width();
288 }
Adam Cohenf9c184a2016-01-15 16:47:43 -0800289 public int getViewportHeight() {
Adam Cohen7d30a372013-07-01 17:03:59 -0700290 return mViewport.height();
291 }
292
293 // Convenience methods to get the offset ASSUMING that we are centering the pages in the
294 // PagedView both horizontally and vertically
295 int getViewportOffsetX() {
296 return (getMeasuredWidth() - getViewportWidth()) / 2;
297 }
298
299 int getViewportOffsetY() {
300 return (getMeasuredHeight() - getViewportHeight()) / 2;
301 }
302
Hyunyoung Song77441692016-06-27 22:00:48 -0700303 public PageIndicator getPageIndicator() {
Adam Cohenedb40762013-07-18 16:45:45 -0700304 return mPageIndicator;
305 }
306
Adam Cohen674531f2013-12-13 15:07:14 -0800307 /**
Tony Wickham29d853c2015-09-08 10:35:56 -0700308 * Returns the index of the currently displayed page. When in free scroll mode, this is the page
309 * that the user was on before entering free scroll mode (e.g. the home screen page they
310 * long-pressed on to enter the overview). Try using {@link #getPageNearestToCenterOfScreen()}
311 * to get the page the user is currently scrolling over.
Winson Chung321e9ee2010-08-09 13:37:56 -0700312 */
Sunny Goyal83a8f042015-05-19 12:52:12 -0700313 public int getCurrentPage() {
Winson Chung86f77532010-08-24 11:08:22 -0700314 return mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700315 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700316
Hyunyoung Songb76cd622015-04-16 14:34:09 -0700317 /**
318 * Returns the index of page to be shown immediately afterwards.
319 */
Vadim Tryshevfedca432015-08-19 17:55:02 -0700320 public int getNextPage() {
Winson Chung360e63f2012-04-27 13:48:05 -0700321 return (mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage;
322 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700323
Adam Cohenf9c184a2016-01-15 16:47:43 -0800324 public int getPageCount() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700325 return getChildCount();
326 }
327
Sunny Goyal83a8f042015-05-19 12:52:12 -0700328 public View getPageAt(int index) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700329 return getChildAt(index);
330 }
331
Adam Cohenae4f1552011-10-20 00:15:42 -0700332 protected int indexToPage(int index) {
333 return index;
334 }
335
Winson Chung321e9ee2010-08-09 13:37:56 -0700336 /**
Winson Chungbbc60d82010-11-11 16:34:41 -0800337 * Updates the scroll of the current page immediately to its final scroll position. We use this
338 * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of
339 * the previous tab page.
340 */
341 protected void updateCurrentPageScroll() {
Adam Cohen0ffac432013-07-10 11:19:26 -0700342 // If the current page is invalid, just reset the scroll position to zero
343 int newX = 0;
344 if (0 <= mCurrentPage && mCurrentPage < getPageCount()) {
Adam Cohenedb40762013-07-18 16:45:45 -0700345 newX = getScrollForPage(mCurrentPage);
Adam Cohen0ffac432013-07-10 11:19:26 -0700346 }
Winson Chungbbc60d82010-11-11 16:34:41 -0800347 scrollTo(newX, 0);
348 mScroller.setFinalX(newX);
Tony Wickham8f7ead32016-04-07 18:46:44 -0700349 forceFinishScroller(true);
Winson Chungbbc60d82010-11-11 16:34:41 -0800350 }
351
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700352 private void abortScrollerAnimation(boolean resetNextPage) {
Adam Cohen4fe4c932013-10-28 16:02:34 -0700353 mScroller.abortAnimation();
354 // We need to clean up the next page here to avoid computeScrollHelper from
355 // updating current page on the pass.
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700356 if (resetNextPage) {
357 mNextPage = INVALID_PAGE;
358 }
Chet Haasebc2f0822012-10-26 17:59:53 -0700359 }
Adam Cohen4fe4c932013-10-28 16:02:34 -0700360
Tony Wickham8f7ead32016-04-07 18:46:44 -0700361 private void forceFinishScroller(boolean resetNextPage) {
Adam Cohen4fe4c932013-10-28 16:02:34 -0700362 mScroller.forceFinished(true);
363 // We need to clean up the next page here to avoid computeScrollHelper from
364 // updating current page on the pass.
Tony Wickham8f7ead32016-04-07 18:46:44 -0700365 if (resetNextPage) {
366 mNextPage = INVALID_PAGE;
367 }
Adam Cohen4fe4c932013-10-28 16:02:34 -0700368 }
369
Adam Cohen6f127a62014-06-12 14:54:41 -0700370 private int validateNewPage(int newPage) {
Adam Cohen6f127a62014-06-12 14:54:41 -0700371 // Ensure that it is clamped by the actual set of children in all cases
Sunny Goyal4d519f22017-10-24 10:32:40 -0700372 return Utilities.boundToRange(newPage, 0, getPageCount() - 1);
Adam Cohen6f127a62014-06-12 14:54:41 -0700373 }
374
Chet Haasebc2f0822012-10-26 17:59:53 -0700375 /**
Winson Chung86f77532010-08-24 11:08:22 -0700376 * Sets the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700377 */
Sunny Goyal1d08f702015-05-04 15:50:25 -0700378 public void setCurrentPage(int currentPage) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800379 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700380 abortScrollerAnimation(true);
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800381 }
Michael Jurkad3ef3062010-11-23 16:23:58 -0800382 // don't introduce any checks like mCurrentPage == currentPage here-- if we change the
383 // the default
384 if (getChildCount() == 0) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800385 return;
386 }
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700387 int prevPage = mCurrentPage;
Adam Cohen6f127a62014-06-12 14:54:41 -0700388 mCurrentPage = validateNewPage(currentPage);
Winson Chung181c3dc2013-07-17 15:36:20 -0700389 updateCurrentPageScroll();
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700390 notifyPageSwitchListener(prevPage);
Winson Chunga12a2502010-12-20 14:41:35 -0800391 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -0700392 }
393
Winson Chung8c87cd82013-07-23 16:20:10 -0700394 /**
Adam Cohen674531f2013-12-13 15:07:14 -0800395 * Should be called whenever the page changes. In the case of a scroll, we wait until the page
396 * has settled.
397 */
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700398 protected void notifyPageSwitchListener(int prevPage) {
Adam Cohen674531f2013-12-13 15:07:14 -0800399 updatePageIndicator();
400 }
401
402 private void updatePageIndicator() {
Winson Chungd2be3812013-07-16 11:11:32 -0700403 // Update the page indicator (when we aren't reordering)
Sunny Goyal4cbf0462014-08-28 16:19:39 -0700404 if (mPageIndicator != null) {
Sunny Goyal53fe1f22016-07-08 08:47:07 -0700405 mPageIndicator.setContentDescription(getPageIndicatorDescription());
Sunny Goyal4cbf0462014-08-28 16:19:39 -0700406 if (!isReordering(false)) {
407 mPageIndicator.setActiveMarker(getNextPage());
408 }
Winson Chungd2be3812013-07-16 11:11:32 -0700409 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700410 }
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700411 protected void pageBeginTransition() {
412 if (!mIsPageInTransition) {
413 mIsPageInTransition = true;
414 onPageBeginTransition();
Michael Jurkad74c9842011-07-10 12:44:21 -0700415 }
Patrick Dubroy1262e362010-10-06 15:49:50 -0700416 }
417
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700418 protected void pageEndTransition() {
419 if (mIsPageInTransition) {
420 mIsPageInTransition = false;
421 onPageEndTransition();
Michael Jurkad74c9842011-07-10 12:44:21 -0700422 }
Michael Jurka0142d492010-08-25 17:46:15 -0700423 }
424
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700425 protected boolean isPageInTransition() {
426 return mIsPageInTransition;
Adam Cohen26976d92011-03-22 15:33:33 -0700427 }
428
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700429 /**
430 * Called when the page starts moving as part of the scroll. Subclasses can override this
431 * to provide custom behavior during animation.
432 */
433 protected void onPageBeginTransition() {
Patrick Dubroy1262e362010-10-06 15:49:50 -0700434 }
435
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700436 /**
437 * Called when the page ends moving as part of the scroll. Subclasses can override this
438 * to provide custom behavior during animation.
439 */
440 protected void onPageEndTransition() {
Adam Cohenc2d6e892014-10-16 09:49:24 -0700441 mWasInOverscroll = false;
Michael Jurka0142d492010-08-25 17:46:15 -0700442 }
443
Winson Chung321e9ee2010-08-09 13:37:56 -0700444 /**
Winson Chung86f77532010-08-24 11:08:22 -0700445 * Registers the specified listener on each page contained in this workspace.
Winson Chung321e9ee2010-08-09 13:37:56 -0700446 *
447 * @param l The listener used to respond to long clicks.
448 */
449 @Override
450 public void setOnLongClickListener(OnLongClickListener l) {
451 mLongClickListener = l;
Winson Chung86f77532010-08-24 11:08:22 -0700452 final int count = getPageCount();
Winson Chung321e9ee2010-08-09 13:37:56 -0700453 for (int i = 0; i < count; i++) {
Winson Chung86f77532010-08-24 11:08:22 -0700454 getPageAt(i).setOnLongClickListener(l);
Winson Chung321e9ee2010-08-09 13:37:56 -0700455 }
Adam Cohen1697b792013-09-17 19:08:21 -0700456 super.setOnLongClickListener(l);
Winson Chung321e9ee2010-08-09 13:37:56 -0700457 }
458
Sunny Goyalc86df472016-02-25 09:19:38 -0800459 protected int getUnboundedScrollX() {
Adam Cohen8d769d62017-06-23 17:27:38 -0700460 return mUnboundedScrollX;
Sunny Goyalc86df472016-02-25 09:19:38 -0800461 }
462
Winson Chung321e9ee2010-08-09 13:37:56 -0700463 @Override
Adam Cohen68d73932010-11-15 10:50:58 -0800464 public void scrollBy(int x, int y) {
Sunny Goyalc86df472016-02-25 09:19:38 -0800465 scrollTo(getUnboundedScrollX() + x, getScrollY() + y);
Adam Cohen68d73932010-11-15 10:50:58 -0800466 }
467
468 @Override
Michael Jurka0142d492010-08-25 17:46:15 -0700469 public void scrollTo(int x, int y) {
Adam Cohenf358a4b2013-07-23 16:47:31 -0700470 // In free scroll mode, we clamp the scrollX
471 if (mFreeScroll) {
Adam Cohenb2b02b92015-06-10 18:40:05 -0700472 // If the scroller is trying to move to a location beyond the maximum allowed
473 // in the free scroll mode, we make sure to end the scroll operation.
Sunny Goyal4d519f22017-10-24 10:32:40 -0700474 if (!mScroller.isFinished() && (x > mMaxScrollX || x < 0)) {
Tony Wickham8f7ead32016-04-07 18:46:44 -0700475 forceFinishScroller(false);
Adam Cohenb2b02b92015-06-10 18:40:05 -0700476 }
477
Sunny Goyal4d519f22017-10-24 10:32:40 -0700478 x = Utilities.boundToRange(x, 0, mMaxScrollX);
Adam Cohenf358a4b2013-07-23 16:47:31 -0700479 }
480
Adam Cohen8d769d62017-06-23 17:27:38 -0700481 mUnboundedScrollX = x;
482
Sunny Goyal70660032015-05-14 00:07:08 -0700483 boolean isXBeforeFirstPage = mIsRtl ? (x > mMaxScrollX) : (x < 0);
484 boolean isXAfterLastPage = mIsRtl ? (x < 0) : (x > mMaxScrollX);
Adam Cohen0ffac432013-07-10 11:19:26 -0700485 if (isXBeforeFirstPage) {
Sunny Goyal4d113a52015-05-27 10:05:28 -0700486 super.scrollTo(mIsRtl ? mMaxScrollX : 0, y);
Adam Cohen68d73932010-11-15 10:50:58 -0800487 if (mAllowOverScroll) {
Adam Cohenc2d6e892014-10-16 09:49:24 -0700488 mWasInOverscroll = true;
Sunny Goyal70660032015-05-14 00:07:08 -0700489 if (mIsRtl) {
Adam Cohen0ffac432013-07-10 11:19:26 -0700490 overScroll(x - mMaxScrollX);
491 } else {
492 overScroll(x);
493 }
Adam Cohen68d73932010-11-15 10:50:58 -0800494 }
Adam Cohen0ffac432013-07-10 11:19:26 -0700495 } else if (isXAfterLastPage) {
Sunny Goyal4d113a52015-05-27 10:05:28 -0700496 super.scrollTo(mIsRtl ? 0 : mMaxScrollX, y);
Adam Cohen68d73932010-11-15 10:50:58 -0800497 if (mAllowOverScroll) {
Adam Cohenc2d6e892014-10-16 09:49:24 -0700498 mWasInOverscroll = true;
Sunny Goyal70660032015-05-14 00:07:08 -0700499 if (mIsRtl) {
Adam Cohen0ffac432013-07-10 11:19:26 -0700500 overScroll(x);
501 } else {
502 overScroll(x - mMaxScrollX);
503 }
Adam Cohen68d73932010-11-15 10:50:58 -0800504 }
505 } else {
Adam Cohenc2d6e892014-10-16 09:49:24 -0700506 if (mWasInOverscroll) {
507 overScroll(0);
508 mWasInOverscroll = false;
509 }
Adam Cohen8d769d62017-06-23 17:27:38 -0700510 mOverScrollX = x;
Adam Cohen68d73932010-11-15 10:50:58 -0800511 super.scrollTo(x, y);
512 }
513
Adam Cohen7d30a372013-07-01 17:03:59 -0700514 // Update the last motion events when scrolling
515 if (isReordering(true)) {
516 float[] p = mapPointFromParentToView(this, mParentDownMotionX, mParentDownMotionY);
517 mLastMotionX = p[0];
518 mLastMotionY = p[1];
519 updateDragViewTranslationDuringDrag();
520 }
Michael Jurka0142d492010-08-25 17:46:15 -0700521 }
522
Adam Cohen53805212013-10-01 10:39:23 -0700523 private void sendScrollAccessibilityEvent() {
524 AccessibilityManager am =
525 (AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
526 if (am.isEnabled()) {
Vadim Tryshevf4715972015-05-08 17:21:03 -0700527 if (mCurrentPage != getNextPage()) {
528 AccessibilityEvent ev =
529 AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_SCROLLED);
Vadim Tryshev7066c122015-05-21 14:06:35 -0700530 ev.setScrollable(true);
531 ev.setScrollX(getScrollX());
532 ev.setScrollY(getScrollY());
533 ev.setMaxScrollX(mMaxScrollX);
534 ev.setMaxScrollY(0);
Adam Cohen53805212013-10-01 10:39:23 -0700535
Vadim Tryshevf4715972015-05-08 17:21:03 -0700536 sendAccessibilityEventUnchecked(ev);
Adam Cohen53805212013-10-01 10:39:23 -0700537 }
Adam Cohen53805212013-10-01 10:39:23 -0700538 }
539 }
540
Michael Jurka0142d492010-08-25 17:46:15 -0700541 // we moved this functionality to a helper function so SmoothPagedView can reuse it
542 protected boolean computeScrollHelper() {
Tony Wickham95cdb3a2016-02-18 14:37:07 -0800543 return computeScrollHelper(true);
544 }
545
546 protected boolean computeScrollHelper(boolean shouldInvalidate) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700547 if (mScroller.computeScrollOffset()) {
Winson Chung557d6ed2011-07-08 15:34:52 -0700548 // Don't bother scrolling if the page does not need to be moved
Sunny Goyal76dbf6f2017-01-03 14:55:47 -0800549 if (getUnboundedScrollX() != mScroller.getCurrX()
Adam Cohen8d769d62017-06-23 17:27:38 -0700550 || getScrollY() != mScroller.getCurrY()
551 || mOverScrollX != mScroller.getCurrX()) {
Adam Cohenf358a4b2013-07-23 16:47:31 -0700552 float scaleX = mFreeScroll ? getScaleX() : 1f;
553 int scrollX = (int) (mScroller.getCurrX() * (1 / scaleX));
554 scrollTo(scrollX, mScroller.getCurrY());
Winson Chung557d6ed2011-07-08 15:34:52 -0700555 }
Tony Wickham95cdb3a2016-02-18 14:37:07 -0800556 if (shouldInvalidate) {
557 invalidate();
558 }
Michael Jurka0142d492010-08-25 17:46:15 -0700559 return true;
Tony Wickham95cdb3a2016-02-18 14:37:07 -0800560 } else if (mNextPage != INVALID_PAGE && shouldInvalidate) {
Adam Cohen53805212013-10-01 10:39:23 -0700561 sendScrollAccessibilityEvent();
562
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700563 int prevPage = mCurrentPage;
Adam Cohen6f127a62014-06-12 14:54:41 -0700564 mCurrentPage = validateNewPage(mNextPage);
Winson Chung86f77532010-08-24 11:08:22 -0700565 mNextPage = INVALID_PAGE;
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700566 notifyPageSwitchListener(prevPage);
Winson Chungb44b5242011-06-13 11:32:14 -0700567
Adam Cohen73aa9752010-11-24 16:26:58 -0800568 // We don't want to trigger a page end moving unless the page has settled
569 // and the user has stopped scrolling
570 if (mTouchState == TOUCH_STATE_REST) {
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700571 pageEndTransition();
Adam Cohen73aa9752010-11-24 16:26:58 -0800572 }
Winson Chungc27d1bb2011-09-29 12:07:42 -0700573
Adam Cohen7d30a372013-07-01 17:03:59 -0700574 onPostReorderingAnimationCompleted();
Adam Cohen53805212013-10-01 10:39:23 -0700575 AccessibilityManager am = (AccessibilityManager)
Adam Cohen0ffac432013-07-10 11:19:26 -0700576 getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
Adam Cohen53805212013-10-01 10:39:23 -0700577 if (am.isEnabled()) {
578 // Notify the user when the page changes
579 announceForAccessibility(getCurrentPageDescription());
Adam Cohen0ffac432013-07-10 11:19:26 -0700580 }
Michael Jurka0142d492010-08-25 17:46:15 -0700581 return true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700582 }
Michael Jurka0142d492010-08-25 17:46:15 -0700583 return false;
584 }
585
586 @Override
587 public void computeScroll() {
588 computeScrollHelper();
Winson Chung321e9ee2010-08-09 13:37:56 -0700589 }
590
Adam Cohen410f3cd2013-09-22 12:09:32 -0700591 public int getNormalChildHeight() {
Sunny Goyalac00cba2017-11-13 15:58:01 -0800592 return getViewportHeight() - getPaddingTop() - getPaddingBottom()
593 - mInsets.top - mInsets.bottom;
Adam Cohen410f3cd2013-09-22 12:09:32 -0700594 }
595
Winson Chung321e9ee2010-08-09 13:37:56 -0700596 @Override
597 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700598 if (getChildCount() == 0) {
Winson Chungf0ea4d32011-06-06 14:27:16 -0700599 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
600 return;
601 }
602
Adam Cohen7d30a372013-07-01 17:03:59 -0700603 // We measure the dimensions of the PagedView to be larger than the pages so that when we
604 // zoom out (and scale down), the view is still contained in the parent
Adam Cohen7d30a372013-07-01 17:03:59 -0700605 int widthMode = MeasureSpec.getMode(widthMeasureSpec);
606 int widthSize = MeasureSpec.getSize(widthMeasureSpec);
607 int heightMode = MeasureSpec.getMode(heightMeasureSpec);
Winson Chung8aad6102012-05-11 16:27:49 -0700608 int heightSize = MeasureSpec.getSize(heightMeasureSpec);
Adam Cohen410f3cd2013-09-22 12:09:32 -0700609
Adam Cohen7d30a372013-07-01 17:03:59 -0700610 mViewport.set(0, 0, widthSize, heightSize);
611
612 if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
613 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
614 return;
Winson Chung321e9ee2010-08-09 13:37:56 -0700615 }
616
Winson Chung8aad6102012-05-11 16:27:49 -0700617 // Return early if we aren't given a proper dimension
618 if (widthSize <= 0 || heightSize <= 0) {
619 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
620 return;
621 }
622
Winson Chung321e9ee2010-08-09 13:37:56 -0700623 // The children are given the same width and height as the workspace
Michael Jurka5f1c5092010-09-03 14:15:02 -0700624 // unless they were set to WRAP_CONTENT
Winson Chung785d2eb2011-04-14 16:08:02 -0700625 if (DEBUG) Log.d(TAG, "PagedView.onMeasure(): " + widthSize + ", " + heightSize);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700626
Sunny Goyalac00cba2017-11-13 15:58:01 -0800627 int myWidthSpec = MeasureSpec.makeMeasureSpec(
628 getViewportWidth() - mInsets.left - mInsets.right, MeasureSpec.EXACTLY);
629 int myHeightSpec = MeasureSpec.makeMeasureSpec(
630 getViewportHeight() - mInsets.top - mInsets.bottom, MeasureSpec.EXACTLY);
Adam Cohen96d30a12013-07-16 18:13:21 -0700631
Sunny Goyalac00cba2017-11-13 15:58:01 -0800632 // measureChildren takes accounts for content padding, we only need to care about extra
633 // space due to insets.
634 measureChildren(myWidthSpec, myHeightSpec);
635 setMeasuredDimension(widthSize, heightSize);
Adam Cohen60b07122011-11-14 17:26:06 -0800636 }
637
Sunny Goyalcf25b522015-07-09 00:01:18 -0700638 @SuppressLint("DrawAllocation")
Winson Chung321e9ee2010-08-09 13:37:56 -0700639 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700640 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700641 if (getChildCount() == 0) {
Winson Chungf0ea4d32011-06-06 14:27:16 -0700642 return;
643 }
644
Winson Chung785d2eb2011-04-14 16:08:02 -0700645 if (DEBUG) Log.d(TAG, "PagedView.onLayout()");
Winson Chung321e9ee2010-08-09 13:37:56 -0700646 final int childCount = getChildCount();
Winson Chung321e9ee2010-08-09 13:37:56 -0700647
Adam Cohen7d30a372013-07-01 17:03:59 -0700648 int offsetX = getViewportOffsetX();
649 int offsetY = getViewportOffsetY();
650
651 // Update the viewport offsets
Vadim Tryshev7af0d442015-05-15 08:48:11 -0700652 mViewport.offset(offsetX, offsetY);
Adam Cohen7d30a372013-07-01 17:03:59 -0700653
Sunny Goyal70660032015-05-14 00:07:08 -0700654 final int startIndex = mIsRtl ? childCount - 1 : 0;
655 final int endIndex = mIsRtl ? -1 : childCount;
656 final int delta = mIsRtl ? -1 : 1;
Adam Cohen0ffac432013-07-10 11:19:26 -0700657
Adam Cohen7d30a372013-07-01 17:03:59 -0700658 int verticalPadding = getPaddingTop() + getPaddingBottom();
Adam Cohenedb40762013-07-18 16:45:45 -0700659
Sunny Goyalac00cba2017-11-13 15:58:01 -0800660 int childLeft = offsetX + getPaddingLeft();
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700661 if (mPageScrolls == null || childCount != mChildCountOnLastLayout) {
662 mPageScrolls = new int[childCount];
Adam Cohenedb40762013-07-18 16:45:45 -0700663 }
664
Adam Cohen0ffac432013-07-10 11:19:26 -0700665 for (int i = startIndex; i != endIndex; i += delta) {
Adam Cohen22f823d2011-09-01 17:22:18 -0700666 final View child = getPageAt(i);
Winson Chung321e9ee2010-08-09 13:37:56 -0700667 if (child.getVisibility() != View.GONE) {
Sunny Goyalac00cba2017-11-13 15:58:01 -0800668 int childTop = offsetY + getPaddingTop() + mInsets.top;
669 childTop += (getViewportHeight() - mInsets.top - mInsets.bottom - verticalPadding
670 - child.getMeasuredHeight()) / 2;
Vladimir Marko2824b072013-10-04 16:42:17 +0100671
Adam Cohen96d30a12013-07-16 18:13:21 -0700672 final int childWidth = child.getMeasuredWidth();
Adam Lesinski6b879f02010-11-04 16:15:23 -0700673 final int childHeight = child.getMeasuredHeight();
Michael Jurkad3ef3062010-11-23 16:23:58 -0800674
Winson Chung785d2eb2011-04-14 16:08:02 -0700675 if (DEBUG) Log.d(TAG, "\tlayout-child" + i + ": " + childLeft + ", " + childTop);
Adam Lesinski6b879f02010-11-04 16:15:23 -0700676 child.layout(childLeft, childTop,
Michael Jurkad3ef3062010-11-23 16:23:58 -0800677 childLeft + child.getMeasuredWidth(), childTop + childHeight);
Adam Cohenedb40762013-07-18 16:45:45 -0700678
Sunny Goyalac00cba2017-11-13 15:58:01 -0800679 int scrollOffsetLeft = getPaddingLeft();
Adam Cohen3b185e22013-10-29 14:45:58 -0700680 mPageScrolls[i] = childLeft - scrollOffsetLeft - offsetX;
Adam Cohen84a465a2013-11-11 18:49:56 +0000681
Sunny Goyalac00cba2017-11-13 15:58:01 -0800682 childLeft += childWidth + mPageSpacing + getChildGap();
Winson Chung321e9ee2010-08-09 13:37:56 -0700683 }
684 }
Winson Chungc3665fa2011-09-14 17:56:27 -0700685
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700686 final LayoutTransition transition = getLayoutTransition();
687 // If the transition is running defer updating max scroll, as some empty pages could
688 // still be present, and a max scroll change could cause sudden jumps in scroll.
689 if (transition != null && transition.isRunning()) {
690 transition.addTransitionListener(new LayoutTransition.TransitionListener() {
691
692 @Override
693 public void startTransition(LayoutTransition transition, ViewGroup container,
694 View view, int transitionType) { }
695
696 @Override
697 public void endTransition(LayoutTransition transition, ViewGroup container,
698 View view, int transitionType) {
699 // Wait until all transitions are complete.
700 if (!transition.isRunning()) {
701 transition.removeTransitionListener(this);
702 updateMaxScrollX();
703 }
704 }
705 });
Adam Cohenf698c6e2013-07-17 18:44:25 -0700706 } else {
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700707 updateMaxScrollX();
Adam Cohenf698c6e2013-07-17 18:44:25 -0700708 }
709
Sunny Goyalcb037ee2015-07-08 16:41:21 -0700710 if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < childCount) {
711 updateCurrentPageScroll();
712 mFirstLayout = false;
713 }
714
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700715 if (mScroller.isFinished() && mChildCountOnLastLayout != childCount) {
Sunny Goyalfe770c92016-09-27 14:38:58 -0700716 setCurrentPage(getNextPage());
Adam Cohenf698c6e2013-07-17 18:44:25 -0700717 }
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700718 mChildCountOnLastLayout = childCount;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700719
720 if (isReordering(true)) {
721 updateDragViewTranslationDuringDrag();
722 }
Winson Chunge3193b92010-09-10 11:44:42 -0700723 }
724
Sunny Goyala1fbd842015-05-20 13:40:27 -0700725 protected int getChildGap() {
726 return 0;
727 }
728
Sunny Goyal4d519f22017-10-24 10:32:40 -0700729 private void updateMaxScrollX() {
Tony Wickhamf549dab2016-05-16 09:54:06 -0700730 mMaxScrollX = computeMaxScrollX();
731 }
732
733 protected int computeMaxScrollX() {
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700734 int childCount = getChildCount();
735 if (childCount > 0) {
Sunny Goyal70660032015-05-14 00:07:08 -0700736 final int index = mIsRtl ? 0 : childCount - 1;
Tony Wickhamf549dab2016-05-16 09:54:06 -0700737 return getScrollForPage(index);
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700738 } else {
Tony Wickhamf549dab2016-05-16 09:54:06 -0700739 return 0;
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700740 }
741 }
742
Adam Cohen3b185e22013-10-29 14:45:58 -0700743 public void setPageSpacing(int pageSpacing) {
744 mPageSpacing = pageSpacing;
745 requestLayout();
746 }
747
Winson Chunge3193b92010-09-10 11:44:42 -0700748 @Override
Michael Jurka8b805b12012-04-18 14:23:14 -0700749 public void onChildViewAdded(View parent, View child) {
Winson Chungd2be3812013-07-16 11:11:32 -0700750 // Update the page indicator, we don't update the page indicator as we
751 // add/remove pages
752 if (mPageIndicator != null && !isReordering(false)) {
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700753 mPageIndicator.addMarker();
Winson Chungd2be3812013-07-16 11:11:32 -0700754 }
755
Adam Cohen2591f6a2011-10-25 14:36:40 -0700756 // This ensures that when children are added, they get the correct transforms / alphas
757 // in accordance with any scroll effects.
Adam Cohen2591f6a2011-10-25 14:36:40 -0700758 invalidate();
759 }
760
Michael Jurka8b805b12012-04-18 14:23:14 -0700761 @Override
762 public void onChildViewRemoved(View parent, View child) {
Tonya361c722017-07-04 09:43:06 -0700763 mCurrentPage = validateNewPage(mCurrentPage);
Adam Cohen7d30a372013-07-01 17:03:59 -0700764 invalidate();
Michael Jurka8b805b12012-04-18 14:23:14 -0700765 }
766
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700767 private void removeMarkerForView() {
Winson Chungd2be3812013-07-16 11:11:32 -0700768 // Update the page indicator, we don't update the page indicator as we
769 // add/remove pages
770 if (mPageIndicator != null && !isReordering(false)) {
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700771 mPageIndicator.removeMarker();
Winson Chungd2be3812013-07-16 11:11:32 -0700772 }
773 }
774
775 @Override
776 public void removeView(View v) {
777 // XXX: We should find a better way to hook into this before the view
778 // gets removed form its parent...
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700779 removeMarkerForView();
Winson Chungd2be3812013-07-16 11:11:32 -0700780 super.removeView(v);
781 }
782 @Override
783 public void removeViewInLayout(View v) {
784 // XXX: We should find a better way to hook into this before the view
785 // gets removed form its parent...
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700786 removeMarkerForView();
Winson Chungd2be3812013-07-16 11:11:32 -0700787 super.removeViewInLayout(v);
788 }
789 @Override
790 public void removeViewAt(int index) {
791 // XXX: We should find a better way to hook into this before the view
792 // gets removed form its parent...
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700793 removeMarkerForView();
Winson Chungd2be3812013-07-16 11:11:32 -0700794 super.removeViewAt(index);
795 }
796 @Override
797 public void removeAllViewsInLayout() {
798 // Update the page indicator, we don't update the page indicator as we
799 // add/remove pages
800 if (mPageIndicator != null) {
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700801 mPageIndicator.setMarkersCount(0);
Winson Chungd2be3812013-07-16 11:11:32 -0700802 }
803
804 super.removeAllViewsInLayout();
805 }
806
Adam Cohen73894962011-10-31 13:17:17 -0700807 protected int getChildOffset(int index) {
Adam Cohen7d30a372013-07-01 17:03:59 -0700808 if (index < 0 || index > getChildCount() - 1) return 0;
809
Adam Cohenf698c6e2013-07-17 18:44:25 -0700810 int offset = getPageAt(index).getLeft() - getViewportOffsetX();
Adam Cohen73894962011-10-31 13:17:17 -0700811
Adam Cohenf698c6e2013-07-17 18:44:25 -0700812 return offset;
Adam Cohen73894962011-10-31 13:17:17 -0700813 }
814
Winson Chung321e9ee2010-08-09 13:37:56 -0700815 @Override
816 public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
Adam Cohenae4f1552011-10-20 00:15:42 -0700817 int page = indexToPage(indexOfChild(child));
Winson Chung86f77532010-08-24 11:08:22 -0700818 if (page != mCurrentPage || !mScroller.isFinished()) {
819 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -0700820 return true;
821 }
822 return false;
823 }
824
825 @Override
826 protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
Winson Chung86f77532010-08-24 11:08:22 -0700827 int focusablePage;
828 if (mNextPage != INVALID_PAGE) {
829 focusablePage = mNextPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700830 } else {
Winson Chung86f77532010-08-24 11:08:22 -0700831 focusablePage = mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700832 }
Winson Chung86f77532010-08-24 11:08:22 -0700833 View v = getPageAt(focusablePage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700834 if (v != null) {
Adam Cohen76fc0852011-06-17 13:26:23 -0700835 return v.requestFocus(direction, previouslyFocusedRect);
Winson Chung321e9ee2010-08-09 13:37:56 -0700836 }
837 return false;
838 }
839
840 @Override
841 public boolean dispatchUnhandledMove(View focused, int direction) {
Sunny Goyal0c4e3722015-12-01 13:21:49 -0800842 if (super.dispatchUnhandledMove(focused, direction)) {
843 return true;
844 }
845
846 if (mIsRtl) {
847 if (direction == View.FOCUS_LEFT) {
848 direction = View.FOCUS_RIGHT;
849 } else if (direction == View.FOCUS_RIGHT) {
850 direction = View.FOCUS_LEFT;
851 }
852 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700853 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -0700854 if (getCurrentPage() > 0) {
855 snapToPage(getCurrentPage() - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -0700856 return true;
857 }
858 } else if (direction == View.FOCUS_RIGHT) {
Winson Chung86f77532010-08-24 11:08:22 -0700859 if (getCurrentPage() < getPageCount() - 1) {
860 snapToPage(getCurrentPage() + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -0700861 return true;
862 }
863 }
Sunny Goyal0c4e3722015-12-01 13:21:49 -0800864 return false;
Winson Chung321e9ee2010-08-09 13:37:56 -0700865 }
866
867 @Override
868 public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
Jon Miranda6a858172016-10-25 16:19:17 -0700869 if (getDescendantFocusability() == FOCUS_BLOCK_DESCENDANTS) {
870 return;
871 }
872
Adam Cohen0ffac432013-07-10 11:19:26 -0700873 // XXX-RTL: This will be fixed in a future CL
Winson Chung86f77532010-08-24 11:08:22 -0700874 if (mCurrentPage >= 0 && mCurrentPage < getPageCount()) {
alanvaf519952012-05-07 17:33:22 -0700875 getPageAt(mCurrentPage).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -0700876 }
877 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -0700878 if (mCurrentPage > 0) {
alanvaf519952012-05-07 17:33:22 -0700879 getPageAt(mCurrentPage - 1).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -0700880 }
881 } else if (direction == View.FOCUS_RIGHT){
Winson Chung86f77532010-08-24 11:08:22 -0700882 if (mCurrentPage < getPageCount() - 1) {
alanvaf519952012-05-07 17:33:22 -0700883 getPageAt(mCurrentPage + 1).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -0700884 }
885 }
886 }
887
888 /**
889 * If one of our descendant views decides that it could be focused now, only
Winson Chung86f77532010-08-24 11:08:22 -0700890 * pass that along if it's on the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700891 *
Winson Chung86f77532010-08-24 11:08:22 -0700892 * This happens when live folders requery, and if they're off page, they
893 * end up calling requestFocus, which pulls it on page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700894 */
895 @Override
896 public void focusableViewAvailable(View focused) {
Winson Chung86f77532010-08-24 11:08:22 -0700897 View current = getPageAt(mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700898 View v = focused;
899 while (true) {
900 if (v == current) {
901 super.focusableViewAvailable(focused);
902 return;
903 }
904 if (v == this) {
905 return;
906 }
907 ViewParent parent = v.getParent();
908 if (parent instanceof View) {
909 v = (View)v.getParent();
910 } else {
911 return;
912 }
913 }
914 }
915
916 /**
917 * {@inheritDoc}
918 */
919 @Override
920 public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
921 if (disallowIntercept) {
922 // We need to make sure to cancel our long press if
923 // a scrollable widget takes over touch events
Adam Cohen22f823d2011-09-01 17:22:18 -0700924 final View currentPage = getPageAt(mCurrentPage);
Winson Chung86f77532010-08-24 11:08:22 -0700925 currentPage.cancelLongPress();
Winson Chung321e9ee2010-08-09 13:37:56 -0700926 }
927 super.requestDisallowInterceptTouchEvent(disallowIntercept);
928 }
929
Patrick Dubroyd0ce1ec2011-01-19 18:47:27 -0800930 /**
931 * Return true if a tap at (x, y) should trigger a flip to the previous page.
932 */
933 protected boolean hitsPreviousPage(float x, float y) {
Sunny Goyal70660032015-05-14 00:07:08 -0700934 if (mIsRtl) {
Adam Cohen0ffac432013-07-10 11:19:26 -0700935 return (x > (getViewportOffsetX() + getViewportWidth() -
Adam Cohen3b185e22013-10-29 14:45:58 -0700936 getPaddingRight() - mPageSpacing));
Adam Cohen0ffac432013-07-10 11:19:26 -0700937 }
Adam Cohen3b185e22013-10-29 14:45:58 -0700938 return (x < getViewportOffsetX() + getPaddingLeft() + mPageSpacing);
Patrick Dubroyd0ce1ec2011-01-19 18:47:27 -0800939 }
940
941 /**
942 * Return true if a tap at (x, y) should trigger a flip to the next page.
943 */
944 protected boolean hitsNextPage(float x, float y) {
Sunny Goyal70660032015-05-14 00:07:08 -0700945 if (mIsRtl) {
Adam Cohen3b185e22013-10-29 14:45:58 -0700946 return (x < getViewportOffsetX() + getPaddingLeft() + mPageSpacing);
Adam Cohen0ffac432013-07-10 11:19:26 -0700947 }
948 return (x > (getViewportOffsetX() + getViewportWidth() -
Adam Cohen3b185e22013-10-29 14:45:58 -0700949 getPaddingRight() - mPageSpacing));
Adam Cohen7d30a372013-07-01 17:03:59 -0700950 }
Winson Chung52aee602013-01-30 12:01:02 -0800951
Adam Cohen7d30a372013-07-01 17:03:59 -0700952 /** Returns whether x and y originated within the buffered viewport */
953 private boolean isTouchPointInViewportWithBuffer(int x, int y) {
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700954 sTmpRect.set(mViewport.left - mViewport.width() / 2, mViewport.top,
Adam Cohen7d30a372013-07-01 17:03:59 -0700955 mViewport.right + mViewport.width() / 2, mViewport.bottom);
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700956 return sTmpRect.contains(x, y);
Adam Cohen7d30a372013-07-01 17:03:59 -0700957 }
958
Winson Chung321e9ee2010-08-09 13:37:56 -0700959 @Override
960 public boolean onInterceptTouchEvent(MotionEvent ev) {
961 /*
962 * This method JUST determines whether we want to intercept the motion.
963 * If we return true, onTouchEvent will be called and we do the actual
964 * scrolling there.
965 */
Adam Cohen6342bba2011-03-10 11:33:35 -0800966 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -0700967
Winson Chung45e1d6e2010-11-09 17:19:49 -0800968 // Skip touch handling if there are no pages to swipe
969 if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev);
970
Winson Chung321e9ee2010-08-09 13:37:56 -0700971 /*
972 * Shortcut the most recurring case: the user is in the dragging
973 * state and he is moving his finger. We want to intercept this
974 * motion.
975 */
976 final int action = ev.getAction();
977 if ((action == MotionEvent.ACTION_MOVE) &&
978 (mTouchState == TOUCH_STATE_SCROLLING)) {
979 return true;
980 }
981
Winson Chung321e9ee2010-08-09 13:37:56 -0700982 switch (action & MotionEvent.ACTION_MASK) {
983 case MotionEvent.ACTION_MOVE: {
984 /*
985 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
986 * whether the user has moved far enough from his original down touch.
987 */
Michael Jurka1ff706b2010-09-14 17:35:20 -0700988 if (mActivePointerId != INVALID_POINTER) {
989 determineScrollingStart(ev);
Michael Jurka1ff706b2010-09-14 17:35:20 -0700990 }
991 // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN
992 // event. in that case, treat the first occurence of a move event as a ACTION_DOWN
993 // i.e. fall through to the next case (don't break)
994 // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events
995 // while it's small- this was causing a crash before we checked for INVALID_POINTER)
Adam Cohen93c97562013-09-26 13:48:01 -0700996 break;
Winson Chung321e9ee2010-08-09 13:37:56 -0700997 }
998
999 case MotionEvent.ACTION_DOWN: {
1000 final float x = ev.getX();
1001 final float y = ev.getY();
1002 // Remember location of down touch
1003 mDownMotionX = x;
Adam Cohen7d30a372013-07-01 17:03:59 -07001004 mDownMotionY = y;
1005 mDownScrollX = getScrollX();
Winson Chung321e9ee2010-08-09 13:37:56 -07001006 mLastMotionX = x;
1007 mLastMotionY = y;
Adam Cohen7d30a372013-07-01 17:03:59 -07001008 float[] p = mapPointFromViewToParent(this, x, y);
1009 mParentDownMotionX = p[0];
1010 mParentDownMotionY = p[1];
Winson Chungc0844aa2011-02-02 15:25:58 -08001011 mLastMotionXRemainder = 0;
Adam Cohenaefd4e12011-02-14 16:39:38 -08001012 mTotalMotionX = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001013 mActivePointerId = ev.getPointerId(0);
Adam Cohen7d30a372013-07-01 17:03:59 -07001014
Winson Chung321e9ee2010-08-09 13:37:56 -07001015 /*
1016 * If being flinged and user touches the screen, initiate drag;
1017 * otherwise don't. mScroller.isFinished should be false when
1018 * being flinged.
1019 */
Michael Jurkafd177c12010-10-19 15:50:43 -07001020 final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX());
Adam Cohena7652152013-11-18 20:06:55 +00001021 final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop / 3);
Adam Cohen2da0a052013-11-08 06:28:17 -08001022
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001023 if (finishedScrolling) {
1024 mTouchState = TOUCH_STATE_REST;
Adam Cohen59b5c792013-12-04 16:09:07 -08001025 if (!mScroller.isFinished() && !mFreeScroll) {
Adam Cohena7652152013-11-18 20:06:55 +00001026 setCurrentPage(getNextPage());
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001027 pageEndTransition();
Adam Cohen2da0a052013-11-08 06:28:17 -08001028 }
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001029 } else {
Adam Cohen7d30a372013-07-01 17:03:59 -07001030 if (isTouchPointInViewportWithBuffer((int) mDownMotionX, (int) mDownMotionY)) {
1031 mTouchState = TOUCH_STATE_SCROLLING;
1032 } else {
1033 mTouchState = TOUCH_STATE_REST;
1034 }
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001035 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001036
Winson Chung321e9ee2010-08-09 13:37:56 -07001037 break;
1038 }
1039
Winson Chung321e9ee2010-08-09 13:37:56 -07001040 case MotionEvent.ACTION_UP:
Jeff Brown1d0867c2010-12-02 18:27:39 -08001041 case MotionEvent.ACTION_CANCEL:
Adam Cohen7d30a372013-07-01 17:03:59 -07001042 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001043 break;
1044
1045 case MotionEvent.ACTION_POINTER_UP:
1046 onSecondaryPointerUp(ev);
Adam Cohen6342bba2011-03-10 11:33:35 -08001047 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001048 break;
1049 }
1050
1051 /*
1052 * The only time we want to intercept motion events is if we are in the
1053 * drag mode.
1054 */
1055 return mTouchState != TOUCH_STATE_REST;
1056 }
1057
Adam Cohenf8d28232011-02-01 21:47:00 -08001058 protected void determineScrollingStart(MotionEvent ev) {
1059 determineScrollingStart(ev, 1.0f);
1060 }
1061
Winson Chung321e9ee2010-08-09 13:37:56 -07001062 /*
1063 * Determines if we should change the touch state to start scrolling after the
1064 * user moves their touch point too far.
1065 */
Adam Cohenf8d28232011-02-01 21:47:00 -08001066 protected void determineScrollingStart(MotionEvent ev, float touchSlopScale) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001067 // Disallow scrolling if we don't have a valid pointer index
Winson Chung321e9ee2010-08-09 13:37:56 -07001068 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
Adam Cohen7d30a372013-07-01 17:03:59 -07001069 if (pointerIndex == -1) return;
1070
1071 // Disallow scrolling if we started the gesture from outside the viewport
Winson Chung321e9ee2010-08-09 13:37:56 -07001072 final float x = ev.getX(pointerIndex);
1073 final float y = ev.getY(pointerIndex);
Adam Cohen7d30a372013-07-01 17:03:59 -07001074 if (!isTouchPointInViewportWithBuffer((int) x, (int) y)) return;
1075
Winson Chung321e9ee2010-08-09 13:37:56 -07001076 final int xDiff = (int) Math.abs(x - mLastMotionX);
Winson Chung321e9ee2010-08-09 13:37:56 -07001077
Adam Cohenf8d28232011-02-01 21:47:00 -08001078 final int touchSlop = Math.round(touchSlopScale * mTouchSlop);
Winson Chung321e9ee2010-08-09 13:37:56 -07001079 boolean xMoved = xDiff > touchSlop;
Winson Chung321e9ee2010-08-09 13:37:56 -07001080
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07001081 if (xMoved) {
1082 // Scroll if the user moved far enough along the X axis
1083 mTouchState = TOUCH_STATE_SCROLLING;
1084 mTotalMotionX += Math.abs(mLastMotionX - x);
1085 mLastMotionX = x;
1086 mLastMotionXRemainder = 0;
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07001087 onScrollInteractionBegin();
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001088 pageBeginTransition();
Tony Wickhamdadb3042016-02-24 11:07:00 -08001089 // Stop listening for things like pinches.
1090 requestDisallowInterceptTouchEvent(true);
Adam Cohenf8d28232011-02-01 21:47:00 -08001091 }
1092 }
1093
1094 protected void cancelCurrentPageLongPress() {
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001095 // Try canceling the long press. It could also have been scheduled
1096 // by a distant descendant, so use the mAllowLongPress flag to block
1097 // everything
1098 final View currentPage = getPageAt(mCurrentPage);
1099 if (currentPage != null) {
1100 currentPage.cancelLongPress();
Winson Chung321e9ee2010-08-09 13:37:56 -07001101 }
1102 }
1103
Adam Cohenb5ba0972011-09-07 18:02:31 -07001104 protected float getScrollProgress(int screenCenter, View v, int page) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001105 final int halfScreenSize = getViewportWidth() / 2;
Adam Cohenb5ba0972011-09-07 18:02:31 -07001106
Adam Cohenedb40762013-07-18 16:45:45 -07001107 int delta = screenCenter - (getScrollForPage(page) + halfScreenSize);
Adam Cohen3b185e22013-10-29 14:45:58 -07001108 int count = getChildCount();
1109
1110 final int totalDistance;
1111
1112 int adjacentPage = page + 1;
Sunny Goyal70660032015-05-14 00:07:08 -07001113 if ((delta < 0 && !mIsRtl) || (delta > 0 && mIsRtl)) {
Adam Cohen3b185e22013-10-29 14:45:58 -07001114 adjacentPage = page - 1;
1115 }
1116
1117 if (adjacentPage < 0 || adjacentPage > count - 1) {
1118 totalDistance = v.getMeasuredWidth() + mPageSpacing;
1119 } else {
1120 totalDistance = Math.abs(getScrollForPage(adjacentPage) - getScrollForPage(page));
1121 }
Adam Cohenb5ba0972011-09-07 18:02:31 -07001122
1123 float scrollProgress = delta / (totalDistance * 1.0f);
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001124 scrollProgress = Math.min(scrollProgress, MAX_SCROLL_PROGRESS);
1125 scrollProgress = Math.max(scrollProgress, - MAX_SCROLL_PROGRESS);
Adam Cohenb5ba0972011-09-07 18:02:31 -07001126 return scrollProgress;
1127 }
1128
Adam Cohenedb40762013-07-18 16:45:45 -07001129 public int getScrollForPage(int index) {
Adam Cohen1f1f45d2013-10-02 09:40:18 -07001130 if (mPageScrolls == null || index >= mPageScrolls.length || index < 0) {
Adam Cohenedb40762013-07-18 16:45:45 -07001131 return 0;
1132 } else {
1133 return mPageScrolls[index];
1134 }
1135 }
1136
Adam Cohen564a2e72013-10-09 14:47:32 -07001137 // While layout transitions are occurring, a child's position may stray from its baseline
1138 // position. This method returns the magnitude of this stray at any given time.
1139 public int getLayoutTransitionOffsetForPage(int index) {
1140 if (mPageScrolls == null || index >= mPageScrolls.length || index < 0) {
1141 return 0;
1142 } else {
1143 View child = getChildAt(index);
Adam Cohen3b185e22013-10-29 14:45:58 -07001144
Sunny Goyalac00cba2017-11-13 15:58:01 -08001145 int scrollOffset = scrollOffset = mIsRtl ? getPaddingRight() : getPaddingLeft();
Adam Cohen564a2e72013-10-09 14:47:32 -07001146 int baselineX = mPageScrolls[index] + scrollOffset + getViewportOffsetX();
1147 return (int) (child.getX() - baselineX);
1148 }
1149 }
1150
Adam Cohenb5ba0972011-09-07 18:02:31 -07001151 protected void dampedOverScroll(float amount) {
Sunny Goyalb72d8b22017-07-14 00:02:27 -07001152 if (Float.compare(amount, 0f) == 0) return;
Adam Cohen8d769d62017-06-23 17:27:38 -07001153
Sunny Goyalb72d8b22017-07-14 00:02:27 -07001154 int overScrollAmount = OverScroll.dampedScroll(amount, getViewportWidth());
Adam Cohen8d769d62017-06-23 17:27:38 -07001155 if (amount < 0) {
1156 mOverScrollX = overScrollAmount;
1157 super.scrollTo(mOverScrollX, getScrollY());
Adam Cohen68d73932010-11-15 10:50:58 -08001158 } else {
Adam Cohen8d769d62017-06-23 17:27:38 -07001159 mOverScrollX = mMaxScrollX + overScrollAmount;
1160 super.scrollTo(mOverScrollX, getScrollY());
Adam Cohen68d73932010-11-15 10:50:58 -08001161 }
1162 invalidate();
1163 }
1164
Adam Cohenb5ba0972011-09-07 18:02:31 -07001165 protected void overScroll(float amount) {
1166 dampedOverScroll(amount);
1167 }
1168
Mario Bertschlerdcc26fc2016-12-21 11:48:48 -08001169 /**
1170 * return true if freescroll has been enabled, false otherwise
1171 */
Sunny Goyalc99cb172017-10-19 16:15:09 -07001172 protected void enableFreeScroll() {
Tony Wickham1c9bf6a2017-11-17 10:25:27 -08001173 enableFreeScroll(false);
1174 }
1175
1176 protected void enableFreeScroll(boolean settleOnPageInFreeScroll) {
Adam Cohenf9618852013-11-08 06:45:03 -08001177 setEnableFreeScroll(true);
Tony Wickham1c9bf6a2017-11-17 10:25:27 -08001178 mSettleOnPageInFreeScroll = settleOnPageInFreeScroll;
Adam Cohenf358a4b2013-07-23 16:47:31 -07001179 }
1180
Sunny Goyalc99cb172017-10-19 16:15:09 -07001181 protected void disableFreeScroll() {
Adam Cohenf9618852013-11-08 06:45:03 -08001182 setEnableFreeScroll(false);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001183 }
1184
Adam Cohenf9618852013-11-08 06:45:03 -08001185 private void setEnableFreeScroll(boolean freeScroll) {
Tony Wickham8f7ead32016-04-07 18:46:44 -07001186 boolean wasFreeScroll = mFreeScroll;
Adam Cohenf358a4b2013-07-23 16:47:31 -07001187 mFreeScroll = freeScroll;
1188
Adam Cohenf9618852013-11-08 06:45:03 -08001189 if (mFreeScroll) {
Sunny Goyal4d519f22017-10-24 10:32:40 -07001190 setCurrentPage(getNextPage());
Tony Wickham8f7ead32016-04-07 18:46:44 -07001191 } else if (wasFreeScroll) {
1192 snapToPage(getNextPage());
Adam Cohenf358a4b2013-07-23 16:47:31 -07001193 }
1194
1195 setEnableOverscroll(!freeScroll);
1196 }
1197
Sunny Goyal2f0ec852015-03-26 13:38:27 -07001198 protected void setEnableOverscroll(boolean enable) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001199 mAllowOverScroll = enable;
1200 }
1201
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001202 private int getNearestHoverOverPageIndex() {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001203 if (mDragView != null) {
1204 int dragX = (int) (mDragView.getLeft() + (mDragView.getMeasuredWidth() / 2)
1205 + mDragView.getTranslationX());
Adam Cohenf358a4b2013-07-23 16:47:31 -07001206 int minDistance = Integer.MAX_VALUE;
1207 int minIndex = indexOfChild(mDragView);
Sunny Goyal4d519f22017-10-24 10:32:40 -07001208 int maxPageNo = getChildCount() - 1;
1209 for (int i = 0; i <= maxPageNo; i++) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001210 View page = getPageAt(i);
Sunny Goyal4d519f22017-10-24 10:32:40 -07001211 int pageX = (page.getLeft() + page.getMeasuredWidth() / 2);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001212 int d = Math.abs(dragX - pageX);
1213 if (d < minDistance) {
1214 minIndex = i;
1215 minDistance = d;
1216 }
1217 }
1218 return minIndex;
1219 }
1220 return -1;
1221 }
1222
Winson Chung321e9ee2010-08-09 13:37:56 -07001223 @Override
1224 public boolean onTouchEvent(MotionEvent ev) {
Adam Cohen1697b792013-09-17 19:08:21 -07001225 super.onTouchEvent(ev);
1226
Winson Chung45e1d6e2010-11-09 17:19:49 -08001227 // Skip touch handling if there are no pages to swipe
1228 if (getChildCount() <= 0) return super.onTouchEvent(ev);
1229
Michael Jurkab8f06722010-10-10 15:58:46 -07001230 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -07001231
1232 final int action = ev.getAction();
1233
1234 switch (action & MotionEvent.ACTION_MASK) {
1235 case MotionEvent.ACTION_DOWN:
1236 /*
1237 * If being flinged and user touches, stop the fling. isFinished
1238 * will be false if being flinged.
1239 */
1240 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -07001241 abortScrollerAnimation(false);
Winson Chung321e9ee2010-08-09 13:37:56 -07001242 }
1243
1244 // Remember where the motion event started
1245 mDownMotionX = mLastMotionX = ev.getX();
Adam Cohen7d30a372013-07-01 17:03:59 -07001246 mDownMotionY = mLastMotionY = ev.getY();
1247 mDownScrollX = getScrollX();
1248 float[] p = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY);
1249 mParentDownMotionX = p[0];
1250 mParentDownMotionY = p[1];
Winson Chungc0844aa2011-02-02 15:25:58 -08001251 mLastMotionXRemainder = 0;
Adam Cohenaefd4e12011-02-14 16:39:38 -08001252 mTotalMotionX = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001253 mActivePointerId = ev.getPointerId(0);
Adam Cohen7d30a372013-07-01 17:03:59 -07001254
Michael Jurka0142d492010-08-25 17:46:15 -07001255 if (mTouchState == TOUCH_STATE_SCROLLING) {
Adam Cohenc2d6e892014-10-16 09:49:24 -07001256 onScrollInteractionBegin();
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001257 pageBeginTransition();
Michael Jurka0142d492010-08-25 17:46:15 -07001258 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001259 break;
1260
1261 case MotionEvent.ACTION_MOVE:
1262 if (mTouchState == TOUCH_STATE_SCROLLING) {
1263 // Scroll to follow the motion event
1264 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
Adam Cohen7d30a372013-07-01 17:03:59 -07001265
1266 if (pointerIndex == -1) return true;
1267
Winson Chung321e9ee2010-08-09 13:37:56 -07001268 final float x = ev.getX(pointerIndex);
Winson Chungc0844aa2011-02-02 15:25:58 -08001269 final float deltaX = mLastMotionX + mLastMotionXRemainder - x;
Winson Chung321e9ee2010-08-09 13:37:56 -07001270
Adam Cohenaefd4e12011-02-14 16:39:38 -08001271 mTotalMotionX += Math.abs(deltaX);
1272
Winson Chungc0844aa2011-02-02 15:25:58 -08001273 // Only scroll and update mLastMotionX if we have moved some discrete amount. We
1274 // keep the remainder because we are actually testing if we've moved from the last
1275 // scrolled position (which is discrete).
1276 if (Math.abs(deltaX) >= 1.0f) {
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07001277 scrollBy((int) deltaX, 0);
Winson Chungc0844aa2011-02-02 15:25:58 -08001278 mLastMotionX = x;
1279 mLastMotionXRemainder = deltaX - (int) deltaX;
Winson Chung321e9ee2010-08-09 13:37:56 -07001280 } else {
1281 awakenScrollBars();
1282 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001283 } else if (mTouchState == TOUCH_STATE_REORDERING) {
1284 // Update the last motion position
1285 mLastMotionX = ev.getX();
1286 mLastMotionY = ev.getY();
1287
1288 // Update the parent down so that our zoom animations take this new movement into
1289 // account
1290 float[] pt = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY);
1291 mParentDownMotionX = pt[0];
1292 mParentDownMotionY = pt[1];
1293 updateDragViewTranslationDuringDrag();
1294
1295 // Find the closest page to the touch point
1296 final int dragViewIndex = indexOfChild(mDragView);
Adam Cohen7d30a372013-07-01 17:03:59 -07001297
Adam Cohen7d30a372013-07-01 17:03:59 -07001298 if (DEBUG) Log.d(TAG, "mLastMotionX: " + mLastMotionX);
1299 if (DEBUG) Log.d(TAG, "mLastMotionY: " + mLastMotionY);
1300 if (DEBUG) Log.d(TAG, "mParentDownMotionX: " + mParentDownMotionX);
1301 if (DEBUG) Log.d(TAG, "mParentDownMotionY: " + mParentDownMotionY);
1302
Adam Cohenf358a4b2013-07-23 16:47:31 -07001303 final int pageUnderPointIndex = getNearestHoverOverPageIndex();
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001304 // Do not allow any page to be moved to 0th position.
1305 if (pageUnderPointIndex > 0 && pageUnderPointIndex != indexOfChild(mDragView)) {
Sunny Goyal4d519f22017-10-24 10:32:40 -07001306 if (0 <= pageUnderPointIndex && pageUnderPointIndex <= getPageCount() - 1 &&
Adam Cohen7d30a372013-07-01 17:03:59 -07001307 pageUnderPointIndex != mSidePageHoverIndex && mScroller.isFinished()) {
1308 mSidePageHoverIndex = pageUnderPointIndex;
1309 mSidePageHoverRunnable = new Runnable() {
1310 @Override
1311 public void run() {
Adam Cohen7d30a372013-07-01 17:03:59 -07001312 // Setup the scroll to the correct page before we swap the views
1313 snapToPage(pageUnderPointIndex);
1314
1315 // For each of the pages between the paged view and the drag view,
1316 // animate them from the previous position to the new position in
1317 // the layout (as a result of the drag view moving in the layout)
1318 int shiftDelta = (dragViewIndex < pageUnderPointIndex) ? -1 : 1;
1319 int lowerIndex = (dragViewIndex < pageUnderPointIndex) ?
1320 dragViewIndex + 1 : pageUnderPointIndex;
1321 int upperIndex = (dragViewIndex > pageUnderPointIndex) ?
1322 dragViewIndex - 1 : pageUnderPointIndex;
1323 for (int i = lowerIndex; i <= upperIndex; ++i) {
1324 View v = getChildAt(i);
1325 // dragViewIndex < pageUnderPointIndex, so after we remove the
1326 // drag view all subsequent views to pageUnderPointIndex will
1327 // shift down.
1328 int oldX = getViewportOffsetX() + getChildOffset(i);
1329 int newX = getViewportOffsetX() + getChildOffset(i + shiftDelta);
1330
1331 // Animate the view translation from its old position to its new
1332 // position
Sunny Goyal5d2fc322015-07-06 22:52:49 -07001333 ObjectAnimator anim = (ObjectAnimator) v.getTag();
Adam Cohen7d30a372013-07-01 17:03:59 -07001334 if (anim != null) {
1335 anim.cancel();
1336 }
1337
1338 v.setTranslationX(oldX - newX);
Sunny Goyal5d2fc322015-07-06 22:52:49 -07001339 anim = LauncherAnimUtils.ofFloat(v, View.TRANSLATION_X, 0);
Adam Cohen7d30a372013-07-01 17:03:59 -07001340 anim.setDuration(REORDERING_REORDER_REPOSITION_DURATION);
Adam Cohen7d30a372013-07-01 17:03:59 -07001341 anim.start();
1342 v.setTag(anim);
1343 }
1344
1345 removeView(mDragView);
Adam Cohen7d30a372013-07-01 17:03:59 -07001346 addView(mDragView, pageUnderPointIndex);
Adam Cohen7d30a372013-07-01 17:03:59 -07001347 mSidePageHoverIndex = -1;
Winson Chung876a6192013-11-06 14:49:50 -08001348 if (mPageIndicator != null) {
1349 mPageIndicator.setActiveMarker(getNextPage());
1350 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001351 }
1352 };
1353 postDelayed(mSidePageHoverRunnable, REORDERING_SIDE_PAGE_HOVER_TIMEOUT);
1354 }
1355 } else {
1356 removeCallbacks(mSidePageHoverRunnable);
1357 mSidePageHoverIndex = -1;
1358 }
Adam Cohen564976a2010-10-13 18:52:07 -07001359 } else {
Winson Chung321e9ee2010-08-09 13:37:56 -07001360 determineScrollingStart(ev);
1361 }
1362 break;
1363
1364 case MotionEvent.ACTION_UP:
1365 if (mTouchState == TOUCH_STATE_SCROLLING) {
1366 final int activePointerId = mActivePointerId;
1367 final int pointerIndex = ev.findPointerIndex(activePointerId);
1368 final float x = ev.getX(pointerIndex);
1369 final VelocityTracker velocityTracker = mVelocityTracker;
1370 velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
1371 int velocityX = (int) velocityTracker.getXVelocity(activePointerId);
Winson Chung9cfd25f2010-10-24 16:09:28 -07001372 final int deltaX = (int) (x - mDownMotionX);
Adam Cohen96d30a12013-07-16 18:13:21 -07001373 final int pageWidth = getPageAt(mCurrentPage).getMeasuredWidth();
Adam Cohen00481b32011-11-18 12:03:48 -08001374 boolean isSignificantMove = Math.abs(deltaX) > pageWidth *
1375 SIGNIFICANT_MOVE_THRESHOLD;
Adam Cohenaefd4e12011-02-14 16:39:38 -08001376
Adam Cohenb64cb5a2011-02-15 13:53:42 -08001377 mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x);
1378
Adam Cohen00481b32011-11-18 12:03:48 -08001379 boolean isFling = mTotalMotionX > MIN_LENGTH_FOR_FLING &&
Sunny Goyal65d9ceb2017-05-08 09:17:42 -07001380 shouldFlingForVelocity(velocityX);
Adam Cohen00481b32011-11-18 12:03:48 -08001381
Adam Cohenf358a4b2013-07-23 16:47:31 -07001382 if (!mFreeScroll) {
1383 // In the case that the page is moved far to one direction and then is flung
1384 // in the opposite direction, we use a threshold to determine whether we should
1385 // just return to the starting page, or if we should skip one further.
1386 boolean returnToOriginalPage = false;
1387 if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD &&
1388 Math.signum(velocityX) != Math.signum(deltaX) && isFling) {
1389 returnToOriginalPage = true;
1390 }
Adam Cohenaefd4e12011-02-14 16:39:38 -08001391
Adam Cohenf358a4b2013-07-23 16:47:31 -07001392 int finalPage;
1393 // We give flings precedence over large moves, which is why we short-circuit our
1394 // test for a large move if a fling has been registered. That is, a large
1395 // move to the left and fling to the right will register as a fling to the right.
Sunny Goyal70660032015-05-14 00:07:08 -07001396 boolean isDeltaXLeft = mIsRtl ? deltaX > 0 : deltaX < 0;
1397 boolean isVelocityXLeft = mIsRtl ? velocityX > 0 : velocityX < 0;
Adam Cohenf358a4b2013-07-23 16:47:31 -07001398 if (((isSignificantMove && !isDeltaXLeft && !isFling) ||
1399 (isFling && !isVelocityXLeft)) && mCurrentPage > 0) {
1400 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage - 1;
1401 snapToPageWithVelocity(finalPage, velocityX);
1402 } else if (((isSignificantMove && isDeltaXLeft && !isFling) ||
1403 (isFling && isVelocityXLeft)) &&
1404 mCurrentPage < getChildCount() - 1) {
1405 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage + 1;
1406 snapToPageWithVelocity(finalPage, velocityX);
1407 } else {
1408 snapToDestination();
Adam Cohenf358a4b2013-07-23 16:47:31 -07001409 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001410 } else {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001411 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -07001412 abortScrollerAnimation(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001413 }
1414
1415 float scaleX = getScaleX();
1416 int vX = (int) (-velocityX * scaleX);
1417 int initialScrollX = (int) (getScrollX() * scaleX);
1418
Adam Cohenf9618852013-11-08 06:45:03 -08001419 mScroller.setInterpolator(mDefaultInterpolator);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001420 mScroller.fling(initialScrollX,
1421 getScrollY(), vX, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0);
Tony Wickham1c9bf6a2017-11-17 10:25:27 -08001422 int unscaledScrollX = (int) (mScroller.getFinalX() / scaleX);
1423 mNextPage = getPageNearestToCenterOfScreen(unscaledScrollX);
1424 int firstPageScroll = getScrollForPage(!mIsRtl ? 0 : getPageCount() - 1);
1425 int lastPageScroll = getScrollForPage(!mIsRtl ? getPageCount() - 1 : 0);
1426 if (mSettleOnPageInFreeScroll && unscaledScrollX > firstPageScroll
1427 && unscaledScrollX < lastPageScroll) {
1428 // Make sure we land directly on a page. If flinging past one of the ends,
1429 // don't change the velocity as it will get stopped at the end anyway.
1430 mScroller.setFinalX((int) (getScrollForPage(mNextPage) * getScaleX()));
1431 // Ensure the scroll/snap doesn't happen too fast;
1432 int extraScrollDuration = OVERSCROLL_PAGE_SNAP_ANIMATION_DURATION
1433 - mScroller.getDuration();
1434 if (extraScrollDuration > 0) {
1435 mScroller.extendDuration(extraScrollDuration);
1436 }
1437 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07001438 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -07001439 }
Adam Cohenc2d6e892014-10-16 09:49:24 -07001440 onScrollInteractionEnd();
Adam Cohencae7f572013-11-04 14:42:52 -08001441 } else if (mTouchState == TOUCH_STATE_PREV_PAGE) {
1442 // at this point we have not moved beyond the touch slop
1443 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
1444 // we can just page
1445 int nextPage = Math.max(0, mCurrentPage - 1);
1446 if (nextPage != mCurrentPage) {
1447 snapToPage(nextPage);
1448 } else {
1449 snapToDestination();
1450 }
Patrick Dubroyd0ce1ec2011-01-19 18:47:27 -08001451 } else if (mTouchState == TOUCH_STATE_NEXT_PAGE) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001452 // at this point we have not moved beyond the touch slop
1453 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
1454 // we can just page
Winson Chung86f77532010-08-24 11:08:22 -07001455 int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1);
1456 if (nextPage != mCurrentPage) {
1457 snapToPage(nextPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001458 } else {
1459 snapToDestination();
1460 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001461 } else if (mTouchState == TOUCH_STATE_REORDERING) {
1462 // Update the last motion position
1463 mLastMotionX = ev.getX();
1464 mLastMotionY = ev.getY();
1465
1466 // Update the parent down so that our zoom animations take this new movement into
1467 // account
1468 float[] pt = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY);
1469 mParentDownMotionX = pt[0];
1470 mParentDownMotionY = pt[1];
1471 updateDragViewTranslationDuringDrag();
Jeff Brown1d0867c2010-12-02 18:27:39 -08001472 } else {
Adam Cohendbdff6b2013-09-18 19:09:15 -07001473 if (!mCancelTap) {
1474 onUnhandledTap(ev);
1475 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001476 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001477
1478 // Remove the callback to wait for the side page hover timeout
1479 removeCallbacks(mSidePageHoverRunnable);
1480 // End any intermediate reordering states
1481 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001482 break;
1483
1484 case MotionEvent.ACTION_CANCEL:
Michael Jurkab8f06722010-10-10 15:58:46 -07001485 if (mTouchState == TOUCH_STATE_SCROLLING) {
1486 snapToDestination();
Sunny Goyal4ff424a2016-08-12 12:46:01 -07001487 onScrollInteractionEnd();
Michael Jurkab8f06722010-10-10 15:58:46 -07001488 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001489 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001490 break;
1491
1492 case MotionEvent.ACTION_POINTER_UP:
1493 onSecondaryPointerUp(ev);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001494 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001495 break;
1496 }
1497
1498 return true;
1499 }
1500
Sunny Goyal65d9ceb2017-05-08 09:17:42 -07001501 protected boolean shouldFlingForVelocity(int velocityX) {
1502 return Math.abs(velocityX) > mFlingThresholdVelocity;
1503 }
1504
Adam Cohen7d30a372013-07-01 17:03:59 -07001505 private void resetTouchState() {
1506 releaseVelocityTracker();
1507 endReordering();
Adam Cohendbdff6b2013-09-18 19:09:15 -07001508 mCancelTap = false;
Adam Cohen7d30a372013-07-01 17:03:59 -07001509 mTouchState = TOUCH_STATE_REST;
1510 mActivePointerId = INVALID_POINTER;
Adam Cohen7d30a372013-07-01 17:03:59 -07001511 }
1512
Adam Cohenc2d6e892014-10-16 09:49:24 -07001513 /**
1514 * Triggered by scrolling via touch
1515 */
1516 protected void onScrollInteractionBegin() {
1517 }
1518
1519 protected void onScrollInteractionEnd() {
1520 }
1521
Adam Cohen1697b792013-09-17 19:08:21 -07001522 protected void onUnhandledTap(MotionEvent ev) {
Tony2fd02082016-10-07 12:50:01 -07001523 Launcher.getLauncher(getContext()).onClick(this);
Adam Cohen1697b792013-09-17 19:08:21 -07001524 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001525
Winson Chung185d7162011-02-28 13:47:29 -08001526 @Override
1527 public boolean onGenericMotionEvent(MotionEvent event) {
1528 if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
1529 switch (event.getAction()) {
1530 case MotionEvent.ACTION_SCROLL: {
1531 // Handle mouse (or ext. device) by shifting the page depending on the scroll
1532 final float vscroll;
1533 final float hscroll;
1534 if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) {
1535 vscroll = 0;
1536 hscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
1537 } else {
1538 vscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
1539 hscroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
1540 }
1541 if (hscroll != 0 || vscroll != 0) {
Sunny Goyal70660032015-05-14 00:07:08 -07001542 boolean isForwardScroll = mIsRtl ? (hscroll < 0 || vscroll < 0)
Adam Cohen0ffac432013-07-10 11:19:26 -07001543 : (hscroll > 0 || vscroll > 0);
1544 if (isForwardScroll) {
Winson Chung185d7162011-02-28 13:47:29 -08001545 scrollRight();
1546 } else {
1547 scrollLeft();
1548 }
1549 return true;
1550 }
1551 }
1552 }
1553 }
1554 return super.onGenericMotionEvent(event);
1555 }
1556
Michael Jurkab8f06722010-10-10 15:58:46 -07001557 private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) {
1558 if (mVelocityTracker == null) {
1559 mVelocityTracker = VelocityTracker.obtain();
1560 }
1561 mVelocityTracker.addMovement(ev);
1562 }
1563
1564 private void releaseVelocityTracker() {
1565 if (mVelocityTracker != null) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001566 mVelocityTracker.clear();
Michael Jurkab8f06722010-10-10 15:58:46 -07001567 mVelocityTracker.recycle();
1568 mVelocityTracker = null;
1569 }
1570 }
1571
Winson Chung321e9ee2010-08-09 13:37:56 -07001572 private void onSecondaryPointerUp(MotionEvent ev) {
1573 final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
1574 MotionEvent.ACTION_POINTER_INDEX_SHIFT;
1575 final int pointerId = ev.getPointerId(pointerIndex);
1576 if (pointerId == mActivePointerId) {
1577 // This was our active pointer going up. Choose a new
1578 // active pointer and adjust accordingly.
1579 // TODO: Make this decision more intelligent.
1580 final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
1581 mLastMotionX = mDownMotionX = ev.getX(newPointerIndex);
1582 mLastMotionY = ev.getY(newPointerIndex);
Winson Chungc0844aa2011-02-02 15:25:58 -08001583 mLastMotionXRemainder = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001584 mActivePointerId = ev.getPointerId(newPointerIndex);
1585 if (mVelocityTracker != null) {
1586 mVelocityTracker.clear();
1587 }
1588 }
Jeff Brown1d0867c2010-12-02 18:27:39 -08001589 }
1590
Winson Chung321e9ee2010-08-09 13:37:56 -07001591 @Override
1592 public void requestChildFocus(View child, View focused) {
1593 super.requestChildFocus(child, focused);
Adam Cohenae4f1552011-10-20 00:15:42 -07001594 int page = indexToPage(indexOfChild(child));
Winson Chung97d85d22011-04-13 11:27:36 -07001595 if (page >= 0 && page != getCurrentPage() && !isInTouchMode()) {
Winson Chung86f77532010-08-24 11:08:22 -07001596 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -07001597 }
1598 }
1599
Adam Cohend19d3ca2010-09-15 14:43:42 -07001600 int getPageNearestToCenterOfScreen() {
Tony Wickham8f7ead32016-04-07 18:46:44 -07001601 return getPageNearestToCenterOfScreen(getScrollX());
1602 }
1603
1604 private int getPageNearestToCenterOfScreen(int scaledScrollX) {
1605 int screenCenter = getViewportOffsetX() + scaledScrollX + (getViewportWidth() / 2);
Adam Cohen22f823d2011-09-01 17:22:18 -07001606 int minDistanceFromScreenCenter = Integer.MAX_VALUE;
Winson Chung321e9ee2010-08-09 13:37:56 -07001607 int minDistanceFromScreenCenterIndex = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -07001608 final int childCount = getChildCount();
1609 for (int i = 0; i < childCount; ++i) {
Adam Cohen22f823d2011-09-01 17:22:18 -07001610 View layout = (View) getPageAt(i);
Adam Cohen96d30a12013-07-16 18:13:21 -07001611 int childWidth = layout.getMeasuredWidth();
Winson Chung321e9ee2010-08-09 13:37:56 -07001612 int halfChildWidth = (childWidth / 2);
Adam Cohen7d30a372013-07-01 17:03:59 -07001613 int childCenter = getViewportOffsetX() + getChildOffset(i) + halfChildWidth;
Winson Chung321e9ee2010-08-09 13:37:56 -07001614 int distanceFromScreenCenter = Math.abs(childCenter - screenCenter);
1615 if (distanceFromScreenCenter < minDistanceFromScreenCenter) {
1616 minDistanceFromScreenCenter = distanceFromScreenCenter;
1617 minDistanceFromScreenCenterIndex = i;
1618 }
1619 }
Adam Cohend19d3ca2010-09-15 14:43:42 -07001620 return minDistanceFromScreenCenterIndex;
1621 }
1622
1623 protected void snapToDestination() {
Adam Cohen8d769d62017-06-23 17:27:38 -07001624 snapToPage(getPageNearestToCenterOfScreen(), getPageSnapDuration());
1625 }
1626
1627 protected boolean isInOverScroll() {
1628 return (mOverScrollX > mMaxScrollX || mOverScrollX < 0);
1629 }
1630
1631 protected int getPageSnapDuration() {
1632 if (isInOverScroll()) {
1633 return OVERSCROLL_PAGE_SNAP_ANIMATION_DURATION;
1634 }
1635 return PAGE_SNAP_ANIMATION_DURATION;
Winson Chung321e9ee2010-08-09 13:37:56 -07001636 }
1637
Adam Cohene0f66b52010-11-23 15:06:07 -08001638 // We want the duration of the page snap animation to be influenced by the distance that
1639 // the screen has to travel, however, we don't want this duration to be effected in a
1640 // purely linear fashion. Instead, we use this method to moderate the effect that the distance
1641 // of travel has on the overall snap duration.
Sunny Goyal4d113a52015-05-27 10:05:28 -07001642 private float distanceInfluenceForSnapDuration(float f) {
Adam Cohene0f66b52010-11-23 15:06:07 -08001643 f -= 0.5f; // center the values about 0.
1644 f *= 0.3f * Math.PI / 2.0f;
1645 return (float) Math.sin(f);
1646 }
1647
Michael Jurka0142d492010-08-25 17:46:15 -07001648 protected void snapToPageWithVelocity(int whichPage, int velocity) {
Adam Cohen6f127a62014-06-12 14:54:41 -07001649 whichPage = validateNewPage(whichPage);
Adam Cohen7d30a372013-07-01 17:03:59 -07001650 int halfScreenSize = getViewportWidth() / 2;
Adam Cohene0f66b52010-11-23 15:06:07 -08001651
Adam Cohenedb40762013-07-18 16:45:45 -07001652 final int newX = getScrollForPage(whichPage);
Sunny Goyalc86df472016-02-25 09:19:38 -08001653 int delta = newX - getUnboundedScrollX();
Adam Cohene0f66b52010-11-23 15:06:07 -08001654 int duration = 0;
1655
Sunny Goyal4d113a52015-05-27 10:05:28 -07001656 if (Math.abs(velocity) < mMinFlingVelocity) {
Adam Cohene0f66b52010-11-23 15:06:07 -08001657 // If the velocity is low enough, then treat this more as an automatic page advance
1658 // as opposed to an apparent physical response to flinging
Sunny Goyal4d113a52015-05-27 10:05:28 -07001659 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
Adam Cohene0f66b52010-11-23 15:06:07 -08001660 return;
1661 }
1662
1663 // Here we compute a "distance" that will be used in the computation of the overall
1664 // snap duration. This is a function of the actual distance that needs to be traveled;
1665 // we keep this value close to half screen size in order to reduce the variance in snap
1666 // duration as a function of the distance the page needs to travel.
Michael Jurka20b7ca92011-06-07 20:09:16 -07001667 float distanceRatio = Math.min(1f, 1.0f * Math.abs(delta) / (2 * halfScreenSize));
Adam Cohene0f66b52010-11-23 15:06:07 -08001668 float distance = halfScreenSize + halfScreenSize *
1669 distanceInfluenceForSnapDuration(distanceRatio);
1670
1671 velocity = Math.abs(velocity);
Adam Cohen265b9a62011-12-07 14:37:18 -08001672 velocity = Math.max(mMinSnapVelocity, velocity);
Adam Cohene0f66b52010-11-23 15:06:07 -08001673
1674 // we want the page's snap velocity to approximately match the velocity at which the
1675 // user flings, so we scale the duration by a value near to the derivative of the scroll
Michael Jurka20b7ca92011-06-07 20:09:16 -07001676 // interpolator at zero, ie. 5. We use 4 to make it a little slower.
1677 duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
Adam Cohene0f66b52010-11-23 15:06:07 -08001678
1679 snapToPage(whichPage, delta, duration);
Michael Jurka0142d492010-08-25 17:46:15 -07001680 }
1681
Sunny Goyal1740d902015-05-27 11:14:01 -07001682 public void snapToPage(int whichPage) {
Sunny Goyal4d113a52015-05-27 10:05:28 -07001683 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07001684 }
1685
Adam Cohenf9c184a2016-01-15 16:47:43 -08001686 public void snapToPageImmediately(int whichPage) {
Sunny Goyal4d113a52015-05-27 10:05:28 -07001687 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION, true, null);
Adam Cohen7d30a372013-07-01 17:03:59 -07001688 }
1689
Michael Jurka0142d492010-08-25 17:46:15 -07001690 protected void snapToPage(int whichPage, int duration) {
Adam Cohenf9618852013-11-08 06:45:03 -08001691 snapToPage(whichPage, duration, false, null);
Adam Cohen7d30a372013-07-01 17:03:59 -07001692 }
1693
Adam Cohenf9618852013-11-08 06:45:03 -08001694 protected void snapToPage(int whichPage, int duration, TimeInterpolator interpolator) {
1695 snapToPage(whichPage, duration, false, interpolator);
1696 }
1697
1698 protected void snapToPage(int whichPage, int duration, boolean immediate,
1699 TimeInterpolator interpolator) {
Adam Cohen6f127a62014-06-12 14:54:41 -07001700 whichPage = validateNewPage(whichPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001701
Adam Cohenedb40762013-07-18 16:45:45 -07001702 int newX = getScrollForPage(whichPage);
Sunny Goyalc86df472016-02-25 09:19:38 -08001703 final int delta = newX - getUnboundedScrollX();
Adam Cohenf9618852013-11-08 06:45:03 -08001704 snapToPage(whichPage, delta, duration, immediate, interpolator);
Michael Jurka0142d492010-08-25 17:46:15 -07001705 }
1706
1707 protected void snapToPage(int whichPage, int delta, int duration) {
Adam Cohenf9618852013-11-08 06:45:03 -08001708 snapToPage(whichPage, delta, duration, false, null);
Adam Cohen7d30a372013-07-01 17:03:59 -07001709 }
Michael Jurka0142d492010-08-25 17:46:15 -07001710
Adam Cohenf9618852013-11-08 06:45:03 -08001711 protected void snapToPage(int whichPage, int delta, int duration, boolean immediate,
1712 TimeInterpolator interpolator) {
Adam Cohen6f127a62014-06-12 14:54:41 -07001713 whichPage = validateNewPage(whichPage);
1714
Adam Cohen7d30a372013-07-01 17:03:59 -07001715 mNextPage = whichPage;
Michael Jurka0142d492010-08-25 17:46:15 -07001716
Winson Chung321e9ee2010-08-09 13:37:56 -07001717 awakenScrollBars(duration);
Adam Cohen7d30a372013-07-01 17:03:59 -07001718 if (immediate) {
1719 duration = 0;
1720 } else if (duration == 0) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001721 duration = Math.abs(delta);
1722 }
1723
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001724 if (duration != 0) {
1725 pageBeginTransition();
1726 }
1727
Adam Cohenf358a4b2013-07-23 16:47:31 -07001728 if (!mScroller.isFinished()) {
Adam Cohenf9618852013-11-08 06:45:03 -08001729 abortScrollerAnimation(false);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001730 }
Adam Cohenf9618852013-11-08 06:45:03 -08001731
1732 if (interpolator != null) {
1733 mScroller.setInterpolator(interpolator);
1734 } else {
1735 mScroller.setInterpolator(mDefaultInterpolator);
1736 }
1737
Sunny Goyalc86df472016-02-25 09:19:38 -08001738 mScroller.startScroll(getUnboundedScrollX(), 0, delta, 0, duration);
Winson Chung80baf5a2010-08-09 16:03:15 -07001739
Adam Cohen674531f2013-12-13 15:07:14 -08001740 updatePageIndicator();
Adam Cohen7d30a372013-07-01 17:03:59 -07001741
1742 // Trigger a compute() to finish switching pages if necessary
1743 if (immediate) {
1744 computeScroll();
Sunny Goyal76dbf6f2017-01-03 14:55:47 -08001745 pageEndTransition();
Adam Cohen7d30a372013-07-01 17:03:59 -07001746 }
1747
Winson Chung321e9ee2010-08-09 13:37:56 -07001748 invalidate();
1749 }
1750
Winson Chung321e9ee2010-08-09 13:37:56 -07001751 public void scrollLeft() {
Adam Cohen2bf63d52013-09-29 17:46:49 -07001752 if (getNextPage() > 0) snapToPage(getNextPage() - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001753 }
1754
1755 public void scrollRight() {
Adam Cohen2bf63d52013-09-29 17:46:49 -07001756 if (getNextPage() < getChildCount() -1) snapToPage(getNextPage() + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001757 }
1758
Adam Cohendbdff6b2013-09-18 19:09:15 -07001759 @Override
1760 public boolean performLongClick() {
1761 mCancelTap = true;
1762 return super.performLongClick();
1763 }
1764
Winson Chung321e9ee2010-08-09 13:37:56 -07001765 public static class SavedState extends BaseSavedState {
Winson Chung86f77532010-08-24 11:08:22 -07001766 int currentPage = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -07001767
1768 SavedState(Parcelable superState) {
1769 super(superState);
1770 }
1771
Adam Cohen091440a2015-03-18 14:16:05 -07001772 @Thunk SavedState(Parcel in) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001773 super(in);
Winson Chung86f77532010-08-24 11:08:22 -07001774 currentPage = in.readInt();
Winson Chung321e9ee2010-08-09 13:37:56 -07001775 }
1776
1777 @Override
1778 public void writeToParcel(Parcel out, int flags) {
1779 super.writeToParcel(out, flags);
Winson Chung86f77532010-08-24 11:08:22 -07001780 out.writeInt(currentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001781 }
1782
1783 public static final Parcelable.Creator<SavedState> CREATOR =
1784 new Parcelable.Creator<SavedState>() {
1785 public SavedState createFromParcel(Parcel in) {
1786 return new SavedState(in);
1787 }
1788
1789 public SavedState[] newArray(int size) {
1790 return new SavedState[size];
1791 }
1792 };
1793 }
1794
Adam Cohen7d30a372013-07-01 17:03:59 -07001795 // Animate the drag view back to the original position
Sunny Goyal4d113a52015-05-27 10:05:28 -07001796 private void animateDragViewToOriginalPosition() {
Adam Cohen7d30a372013-07-01 17:03:59 -07001797 if (mDragView != null) {
Sunny Goyal9e76f682017-02-13 12:13:43 -08001798 Animator anim = LauncherAnimUtils.ofPropertyValuesHolder(mDragView,
1799 new PropertyListBuilder()
1800 .scale(1)
1801 .translationX(0)
1802 .translationY(0)
1803 .build())
Sunny Goyal5d2fc322015-07-06 22:52:49 -07001804 .setDuration(REORDERING_DROP_REPOSITION_DURATION);
Adam Cohen7d30a372013-07-01 17:03:59 -07001805 anim.addListener(new AnimatorListenerAdapter() {
1806 @Override
1807 public void onAnimationEnd(Animator animation) {
1808 onPostReorderingAnimationCompleted();
1809 }
1810 });
1811 anim.start();
1812 }
Winson Chung3ac74c52011-06-30 17:39:37 -07001813 }
1814
Sunny Goyal1d08f702015-05-04 15:50:25 -07001815 public void onStartReordering() {
Adam Cohen7d30a372013-07-01 17:03:59 -07001816 // Set the touch state to reordering (allows snapping to pages, dragging a child, etc.)
1817 mTouchState = TOUCH_STATE_REORDERING;
1818 mIsReordering = true;
1819
Adam Cohen7d30a372013-07-01 17:03:59 -07001820 // We must invalidate to trigger a redraw to update the layers such that the drag view
1821 // is always drawn on top
1822 invalidate();
1823 }
1824
Adam Cohen091440a2015-03-18 14:16:05 -07001825 @Thunk void onPostReorderingAnimationCompleted() {
Adam Cohen7d30a372013-07-01 17:03:59 -07001826 // Trigger the callback when reordering has settled
1827 --mPostReorderingPreZoomInRemainingAnimationCount;
1828 if (mPostReorderingPreZoomInRunnable != null &&
1829 mPostReorderingPreZoomInRemainingAnimationCount == 0) {
1830 mPostReorderingPreZoomInRunnable.run();
1831 mPostReorderingPreZoomInRunnable = null;
1832 }
1833 }
1834
Sunny Goyal1d08f702015-05-04 15:50:25 -07001835 public void onEndReordering() {
Adam Cohen7d30a372013-07-01 17:03:59 -07001836 mIsReordering = false;
Adam Cohen7d30a372013-07-01 17:03:59 -07001837 }
1838
Adam Cohenf358a4b2013-07-23 16:47:31 -07001839 public boolean startReordering(View v) {
Adam Cohen93c97562013-09-26 13:48:01 -07001840 int dragViewIndex = indexOfChild(v);
1841
Sunny Goyalda4fe1a2016-05-26 16:05:17 -07001842 // Do not allow the first page to be moved around
1843 if (mTouchState != TOUCH_STATE_REST || dragViewIndex <= 0) return false;
Adam Cohen93c97562013-09-26 13:48:01 -07001844
Adam Cohen7d30a372013-07-01 17:03:59 -07001845 // Check if we are within the reordering range
Sunny Goyal4d519f22017-10-24 10:32:40 -07001846 if (0 <= dragViewIndex && dragViewIndex <= getPageCount() - 1) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001847 // Find the drag view under the pointer
1848 mDragView = getChildAt(dragViewIndex);
1849 mDragView.animate().scaleX(1.15f).scaleY(1.15f).setDuration(100).start();
1850 mDragViewBaselineLeft = mDragView.getLeft();
Sunny Goyal4d519f22017-10-24 10:32:40 -07001851 mReorderingStarted = true;
1852
Adam Cohenf9618852013-11-08 06:45:03 -08001853 snapToPage(getPageNearestToCenterOfScreen());
1854 disableFreeScroll();
Adam Cohenf358a4b2013-07-23 16:47:31 -07001855 onStartReordering();
Adam Cohen7d30a372013-07-01 17:03:59 -07001856 return true;
1857 }
1858 return false;
1859 }
1860
1861 boolean isReordering(boolean testTouchState) {
1862 boolean state = mIsReordering;
1863 if (testTouchState) {
1864 state &= (mTouchState == TOUCH_STATE_REORDERING);
1865 }
1866 return state;
1867 }
1868 void endReordering() {
1869 // For simplicity, we call endReordering sometimes even if reordering was never started.
1870 // In that case, we don't want to do anything.
1871 if (!mReorderingStarted) return;
1872 mReorderingStarted = false;
1873
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001874 mPostReorderingPreZoomInRunnable = new Runnable() {
1875 public void run() {
Mario Bertschlerdcc26fc2016-12-21 11:48:48 -08001876 // If we haven't flung-to-delete the current child,
1877 // then we just animate the drag view back into position
1878 onEndReordering();
1879
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001880 enableFreeScroll();
Mario Bertschlerdcc26fc2016-12-21 11:48:48 -08001881 }
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001882 };
Adam Cohen7d30a372013-07-01 17:03:59 -07001883
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001884 mPostReorderingPreZoomInRemainingAnimationCount =
1885 NUM_ANIMATIONS_RUNNING_BEFORE_ZOOM_OUT;
1886 // Snap to the current page
1887 snapToPage(indexOfChild(mDragView), 0);
1888 // Animate the drag view back to the front position
1889 animateDragViewToOriginalPosition();
Adam Cohen7d30a372013-07-01 17:03:59 -07001890 }
1891
Winson Chung6a0f57d2011-06-29 20:10:49 -07001892 /* Accessibility */
Sunny Goyalcf25b522015-07-09 00:01:18 -07001893 @SuppressWarnings("deprecation")
Winson Chung6a0f57d2011-06-29 20:10:49 -07001894 @Override
1895 public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
1896 super.onInitializeAccessibilityNodeInfo(info);
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001897 info.setScrollable(getPageCount() > 1);
1898 if (getCurrentPage() < getPageCount() - 1) {
1899 info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
1900 }
1901 if (getCurrentPage() > 0) {
1902 info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD);
1903 }
Vadim Tryshev7af0d442015-05-15 08:48:11 -07001904 info.setClassName(getClass().getName());
1905
1906 // Accessibility-wise, PagedView doesn't support long click, so disabling it.
1907 // Besides disabling the accessibility long-click, this also prevents this view from getting
1908 // accessibility focus.
1909 info.setLongClickable(false);
Sunny Goyala52ecb02016-12-16 15:04:51 -08001910 info.removeAction(AccessibilityNodeInfo.AccessibilityAction.ACTION_LONG_CLICK);
Winson Chung6a0f57d2011-06-29 20:10:49 -07001911 }
1912
1913 @Override
Alan Viverette254139a2013-10-08 13:13:46 -07001914 public void sendAccessibilityEvent(int eventType) {
1915 // Don't let the view send real scroll events.
1916 if (eventType != AccessibilityEvent.TYPE_VIEW_SCROLLED) {
1917 super.sendAccessibilityEvent(eventType);
1918 }
1919 }
1920
1921 @Override
Winson Chung6a0f57d2011-06-29 20:10:49 -07001922 public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
1923 super.onInitializeAccessibilityEvent(event);
Vadim Tryshev7066c122015-05-21 14:06:35 -07001924 event.setScrollable(getPageCount() > 1);
Winson Chung6a0f57d2011-06-29 20:10:49 -07001925 }
1926
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001927 @Override
1928 public boolean performAccessibilityAction(int action, Bundle arguments) {
1929 if (super.performAccessibilityAction(action, arguments)) {
1930 return true;
1931 }
1932 switch (action) {
1933 case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: {
1934 if (getCurrentPage() < getPageCount() - 1) {
1935 scrollRight();
1936 return true;
1937 }
1938 } break;
1939 case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: {
1940 if (getCurrentPage() > 0) {
1941 scrollLeft();
1942 return true;
1943 }
1944 } break;
1945 }
1946 return false;
1947 }
1948
Sunny Goyal53fe1f22016-07-08 08:47:07 -07001949 protected String getPageIndicatorDescription() {
1950 return getCurrentPageDescription();
1951 }
1952
Adam Cohen0ffac432013-07-10 11:19:26 -07001953 protected String getCurrentPageDescription() {
Sunny Goyalf4f89ef2015-09-02 15:06:12 -07001954 return getContext().getString(R.string.default_scroll_format,
Adam Cohen0ffac432013-07-10 11:19:26 -07001955 getNextPage() + 1, getChildCount());
1956 }
1957
Winson Chungd11265e2011-08-30 13:37:23 -07001958 @Override
1959 public boolean onHoverEvent(android.view.MotionEvent event) {
1960 return true;
1961 }
Adam Cohen5084cba2013-09-03 12:01:16 -07001962}