blob: 1fee4c23d04cd477f3d3c6dc64297c043ccf1389 [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;
Adam Cohen7d30a372013-07-01 17:03:59 -070021import android.animation.AnimatorSet;
22import android.animation.ObjectAnimator;
23import android.animation.TimeInterpolator;
Winson Chungbb6f6a52011-07-25 17:55:44 -070024import android.animation.ValueAnimator;
Adam Cohen7d30a372013-07-01 17:03:59 -070025import android.animation.ValueAnimator.AnimatorUpdateListener;
Winson Chung321e9ee2010-08-09 13:37:56 -070026import android.content.Context;
Adam Cohen9c4949e2010-10-05 12:27:22 -070027import android.content.res.TypedArray;
Winson Chung321e9ee2010-08-09 13:37:56 -070028import android.graphics.Canvas;
Adam Cohen7d30a372013-07-01 17:03:59 -070029import android.graphics.Matrix;
30import android.graphics.PointF;
Winson Chung321e9ee2010-08-09 13:37:56 -070031import android.graphics.Rect;
Svetoslav Ganov08055f62012-05-15 11:06:36 -070032import android.os.Bundle;
Winson Chung321e9ee2010-08-09 13:37:56 -070033import android.os.Parcel;
34import android.os.Parcelable;
Adam Cohen53805212013-10-01 10:39:23 -070035import android.support.v4.view.accessibility.AccessibilityEventCompat;
Winson Chung321e9ee2010-08-09 13:37:56 -070036import android.util.AttributeSet;
Adam Cohen7d30a372013-07-01 17:03:59 -070037import android.util.DisplayMetrics;
Winson Chung785d2eb2011-04-14 16:08:02 -070038import android.util.Log;
Winson Chung185d7162011-02-28 13:47:29 -080039import android.view.InputDevice;
40import android.view.KeyEvent;
Winson Chung321e9ee2010-08-09 13:37:56 -070041import android.view.MotionEvent;
42import android.view.VelocityTracker;
43import android.view.View;
44import android.view.ViewConfiguration;
45import android.view.ViewGroup;
46import android.view.ViewParent;
Winson Chung6a0f57d2011-06-29 20:10:49 -070047import android.view.accessibility.AccessibilityEvent;
Winson Chungc27d1bb2011-09-29 12:07:42 -070048import android.view.accessibility.AccessibilityManager;
Winson Chung6a0f57d2011-06-29 20:10:49 -070049import android.view.accessibility.AccessibilityNodeInfo;
Adam Cohen7d30a372013-07-01 17:03:59 -070050import android.view.animation.AnimationUtils;
51import android.view.animation.DecelerateInterpolator;
Adam Cohene0f66b52010-11-23 15:06:07 -080052import android.view.animation.Interpolator;
Adam Cohen7d30a372013-07-01 17:03:59 -070053import android.view.animation.LinearInterpolator;
Winson Chung321e9ee2010-08-09 13:37:56 -070054import android.widget.Scroller;
55
Winson Chung6a0f57d2011-06-29 20:10:49 -070056import java.util.ArrayList;
57
Winson Chungc58497e2013-09-03 17:48:37 -070058interface Page {
59 public int getPageChildCount();
60 public View getChildOnPageAt(int i);
61 public void removeAllViewsOnPage();
62 public void removeViewOnPageAt(int i);
63 public int indexOfChildOnPage(View v);
64}
65
Winson Chung321e9ee2010-08-09 13:37:56 -070066/**
67 * An abstraction of the original Workspace which supports browsing through a
Michael Jurka0142d492010-08-25 17:46:15 -070068 * sequential list of "pages"
Winson Chung321e9ee2010-08-09 13:37:56 -070069 */
Michael Jurka8b805b12012-04-18 14:23:14 -070070public abstract class PagedView extends ViewGroup implements ViewGroup.OnHierarchyChangeListener {
Winson Chung321e9ee2010-08-09 13:37:56 -070071 private static final String TAG = "PagedView";
Winson Chung785d2eb2011-04-14 16:08:02 -070072 private static final boolean DEBUG = false;
Michael Jurka0142d492010-08-25 17:46:15 -070073 protected static final int INVALID_PAGE = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -070074
Winson Chung86f77532010-08-24 11:08:22 -070075 // the min drag distance for a fling to register, to prevent random page shifts
Winson Chung9cfd25f2010-10-24 16:09:28 -070076 private static final int MIN_LENGTH_FOR_FLING = 25;
Winson Chung321e9ee2010-08-09 13:37:56 -070077
Adam Cohen7d30a372013-07-01 17:03:59 -070078 protected static final int PAGE_SNAP_ANIMATION_DURATION = 750;
Winson Chungf0c6ae02012-03-21 16:10:31 -070079 protected static final int SLOW_PAGE_SNAP_ANIMATION_DURATION = 950;
Michael Jurka0142d492010-08-25 17:46:15 -070080 protected static final float NANOTIME_DIV = 1000000000.0f;
Winson Chung321e9ee2010-08-09 13:37:56 -070081
Adam Cohenb5ba0972011-09-07 18:02:31 -070082 private static final float OVERSCROLL_ACCELERATE_FACTOR = 2;
Winson Chungb26f3d62011-06-02 10:49:29 -070083 private static final float OVERSCROLL_DAMP_FACTOR = 0.14f;
Winson Chung867ca622012-02-21 15:48:35 -080084
Adam Cohenb64cb5a2011-02-15 13:53:42 -080085 private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.33f;
Adam Cohen00481b32011-11-18 12:03:48 -080086 // The page is moved more than halfway, automatically move to the next page on touch up.
87 private static final float SIGNIFICANT_MOVE_THRESHOLD = 0.4f;
Adam Cohen68d73932010-11-15 10:50:58 -080088
Adam Cohen265b9a62011-12-07 14:37:18 -080089 // The following constants need to be scaled based on density. The scaled versions will be
90 // assigned to the corresponding member variables below.
91 private static final int FLING_THRESHOLD_VELOCITY = 500;
92 private static final int MIN_SNAP_VELOCITY = 1500;
93 private static final int MIN_FLING_VELOCITY = 250;
94
Adam Cohen7d30a372013-07-01 17:03:59 -070095 // We are disabling touch interaction of the widget region for factory ROM.
96 private static final boolean DISABLE_TOUCH_INTERACTION = false;
Adam Cohenf358a4b2013-07-23 16:47:31 -070097 private static final boolean DISABLE_TOUCH_SIDE_PAGES = true;
Adam Cohendedbd962013-07-11 14:21:49 -070098 private static final boolean DISABLE_FLING_TO_DELETE = true;
Adam Cohen7d30a372013-07-01 17:03:59 -070099
Adam Cohen21cd0022013-10-09 18:57:02 -0700100 public static final int INVALID_RESTORE_PAGE = -1001;
101
Adam Cohenf358a4b2013-07-23 16:47:31 -0700102 private boolean mFreeScroll = false;
103 private int mFreeScrollMinScrollX = -1;
104 private int mFreeScrollMaxScrollX = -1;
105
Winson Chung8aad6102012-05-11 16:27:49 -0700106 static final int AUTOMATIC_PAGE_SPACING = -1;
107
Adam Cohen265b9a62011-12-07 14:37:18 -0800108 protected int mFlingThresholdVelocity;
109 protected int mMinFlingVelocity;
110 protected int mMinSnapVelocity;
Michael Jurka0142d492010-08-25 17:46:15 -0700111
Adam Cohenb5ba0972011-09-07 18:02:31 -0700112 protected float mDensity;
Michael Jurka0142d492010-08-25 17:46:15 -0700113 protected float mSmoothingTime;
114 protected float mTouchX;
115
116 protected boolean mFirstLayout = true;
Adam Cohen410f3cd2013-09-22 12:09:32 -0700117 private int mNormalChildHeight;
Michael Jurka0142d492010-08-25 17:46:15 -0700118
119 protected int mCurrentPage;
Adam Cohen21cd0022013-10-09 18:57:02 -0700120 protected int mRestorePage = INVALID_RESTORE_PAGE;
Adam Cohenf698c6e2013-07-17 18:44:25 -0700121 protected int mChildCountOnLastLayout;
Adam Cohene61a9a22013-06-11 15:45:31 -0700122
Michael Jurka0142d492010-08-25 17:46:15 -0700123 protected int mNextPage = INVALID_PAGE;
Adam Cohen68d73932010-11-15 10:50:58 -0800124 protected int mMaxScrollX;
Michael Jurka0142d492010-08-25 17:46:15 -0700125 protected Scroller mScroller;
Winson Chung321e9ee2010-08-09 13:37:56 -0700126 private VelocityTracker mVelocityTracker;
127
Adam Cohen7d30a372013-07-01 17:03:59 -0700128 private float mParentDownMotionX;
129 private float mParentDownMotionY;
Winson Chung321e9ee2010-08-09 13:37:56 -0700130 private float mDownMotionX;
Adam Cohen7d30a372013-07-01 17:03:59 -0700131 private float mDownMotionY;
132 private float mDownScrollX;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700133 private float mDragViewBaselineLeft;
Michael Jurka7426c422010-11-11 15:23:47 -0800134 protected float mLastMotionX;
Winson Chungc0844aa2011-02-02 15:25:58 -0800135 protected float mLastMotionXRemainder;
Michael Jurka7426c422010-11-11 15:23:47 -0800136 protected float mLastMotionY;
Adam Cohenaefd4e12011-02-14 16:39:38 -0800137 protected float mTotalMotionX;
Adam Cohenf34bab52010-09-30 14:11:56 -0700138 private int mLastScreenCenter = -1;
Adam Cohenedb40762013-07-18 16:45:45 -0700139
Adam Cohendbdff6b2013-09-18 19:09:15 -0700140 private boolean mCancelTap;
141
Adam Cohenedb40762013-07-18 16:45:45 -0700142 private int[] mPageScrolls;
Winson Chung321e9ee2010-08-09 13:37:56 -0700143
Michael Jurka0142d492010-08-25 17:46:15 -0700144 protected final static int TOUCH_STATE_REST = 0;
145 protected final static int TOUCH_STATE_SCROLLING = 1;
146 protected final static int TOUCH_STATE_PREV_PAGE = 2;
147 protected final static int TOUCH_STATE_NEXT_PAGE = 3;
Adam Cohen7d30a372013-07-01 17:03:59 -0700148 protected final static int TOUCH_STATE_REORDERING = 4;
149
Adam Cohene45440e2010-10-14 18:33:38 -0700150 protected final static float ALPHA_QUANTIZE_LEVEL = 0.0001f;
Winson Chung321e9ee2010-08-09 13:37:56 -0700151
Michael Jurka0142d492010-08-25 17:46:15 -0700152 protected int mTouchState = TOUCH_STATE_REST;
Adam Cohen2591f6a2011-10-25 14:36:40 -0700153 protected boolean mForceScreenScrolled = false;
Winson Chung321e9ee2010-08-09 13:37:56 -0700154
Michael Jurka0142d492010-08-25 17:46:15 -0700155 protected OnLongClickListener mLongClickListener;
Winson Chung321e9ee2010-08-09 13:37:56 -0700156
Michael Jurka7426c422010-11-11 15:23:47 -0800157 protected int mTouchSlop;
Winson Chung321e9ee2010-08-09 13:37:56 -0700158 private int mPagingTouchSlop;
159 private int mMaximumVelocity;
Adam Cohen9c4949e2010-10-05 12:27:22 -0700160 protected int mPageLayoutPaddingTop;
161 protected int mPageLayoutPaddingBottom;
162 protected int mPageLayoutPaddingLeft;
163 protected int mPageLayoutPaddingRight;
Winson Chungdf4b83d2010-10-20 17:49:27 -0700164 protected int mPageLayoutWidthGap;
165 protected int mPageLayoutHeightGap;
Michael Jurka87b14902011-05-25 22:13:09 -0700166 protected int mCellCountX = 0;
167 protected int mCellCountY = 0;
Winson Chung7da10252010-10-28 16:07:04 -0700168 protected boolean mCenterPagesVertically;
Adam Cohen68d73932010-11-15 10:50:58 -0800169 protected boolean mAllowOverScroll = true;
170 protected int mUnboundedScrollX;
Michael Jurkadde558b2011-11-09 22:09:06 -0800171 protected int[] mTempVisiblePagesRange = new int[2];
Michael Jurka5e368ff2012-05-14 23:13:15 -0700172 protected boolean mForceDrawAllChildrenNextFrame;
Winson Chung321e9ee2010-08-09 13:37:56 -0700173
Michael Jurka8b805b12012-04-18 14:23:14 -0700174 // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. Otherwise
Adam Cohenebea84d2011-11-09 17:20:41 -0800175 // it is equal to the scaled overscroll position. We use a separate value so as to prevent
176 // the screens from continuing to translate beyond the normal bounds.
177 protected int mOverScrollX;
178
Michael Jurka5f1c5092010-09-03 14:15:02 -0700179 protected static final int INVALID_POINTER = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -0700180
Michael Jurka5f1c5092010-09-03 14:15:02 -0700181 protected int mActivePointerId = INVALID_POINTER;
Winson Chung321e9ee2010-08-09 13:37:56 -0700182
Winson Chung86f77532010-08-24 11:08:22 -0700183 private PageSwitchListener mPageSwitchListener;
Winson Chung321e9ee2010-08-09 13:37:56 -0700184
Michael Jurkae326f182011-11-21 14:05:46 -0800185 protected ArrayList<Boolean> mDirtyPageContent;
Winson Chung321e9ee2010-08-09 13:37:56 -0700186
Michael Jurka0142d492010-08-25 17:46:15 -0700187 // If true, syncPages and syncPageItems will be called to refresh pages
188 protected boolean mContentIsRefreshable = true;
189
190 // If true, modify alpha of neighboring pages as user scrolls left/right
Adam Cohen7d30a372013-07-01 17:03:59 -0700191 protected boolean mFadeInAdjacentScreens = false;
Michael Jurka0142d492010-08-25 17:46:15 -0700192
193 // It true, use a different slop parameter (pagingTouchSlop = 2 * touchSlop) for deciding
194 // to switch to a new page
195 protected boolean mUsePagingTouchSlop = true;
196
Michael Jurka8b805b12012-04-18 14:23:14 -0700197 // If true, the subclass should directly update scrollX itself in its computeScroll method
Michael Jurka0142d492010-08-25 17:46:15 -0700198 // (SmoothPagedView does this)
199 protected boolean mDeferScrollUpdate = false;
Winson Chung9c0565f2013-07-19 13:49:06 -0700200 protected boolean mDeferLoadAssociatedPagesUntilScrollCompletes = false;
Michael Jurka0142d492010-08-25 17:46:15 -0700201
Patrick Dubroy1262e362010-10-06 15:49:50 -0700202 protected boolean mIsPageMoving = false;
203
Winson Chungf0ea4d32011-06-06 14:27:16 -0700204 // All syncs and layout passes are deferred until data is ready.
205 protected boolean mIsDataReady = false;
206
Adam Cohen7d30a372013-07-01 17:03:59 -0700207 protected boolean mAllowLongPress = true;
208
Winson Chungd2be3812013-07-16 11:11:32 -0700209 // Page Indicator
210 private int mPageIndicatorViewId;
211 private PageIndicator mPageIndicator;
Winson Chungc58497e2013-09-03 17:48:37 -0700212 private boolean mAllowPagedViewAnimations = true;
Winson Chung007c6982011-06-14 13:27:53 -0700213
Adam Cohen7d30a372013-07-01 17:03:59 -0700214 // The viewport whether the pages are to be contained (the actual view may be larger than the
215 // viewport)
216 private Rect mViewport = new Rect();
217
218 // Reordering
219 // We use the min scale to determine how much to expand the actually PagedView measured
220 // dimensions such that when we are zoomed out, the view is not clipped
221 private int REORDERING_DROP_REPOSITION_DURATION = 200;
222 protected int REORDERING_REORDER_REPOSITION_DURATION = 300;
223 protected int REORDERING_ZOOM_IN_OUT_DURATION = 250;
Adam Cohenf358a4b2013-07-23 16:47:31 -0700224 private int REORDERING_SIDE_PAGE_HOVER_TIMEOUT = 80;
Adam Cohen7d30a372013-07-01 17:03:59 -0700225 private float mMinScale = 1f;
Winson Chungc58497e2013-09-03 17:48:37 -0700226 private boolean mUseMinScale = false;
Adam Cohen7d30a372013-07-01 17:03:59 -0700227 protected View mDragView;
228 protected AnimatorSet mZoomInOutAnim;
229 private Runnable mSidePageHoverRunnable;
230 private int mSidePageHoverIndex = -1;
231 // This variable's scope is only for the duration of startReordering() and endReordering()
232 private boolean mReorderingStarted = false;
233 // This variable's scope is for the duration of startReordering() and after the zoomIn()
234 // animation after endReordering()
235 private boolean mIsReordering;
236 // The runnable that settles the page after snapToPage and animateDragViewToOriginalPosition
237 private int NUM_ANIMATIONS_RUNNING_BEFORE_ZOOM_OUT = 2;
238 private int mPostReorderingPreZoomInRemainingAnimationCount;
239 private Runnable mPostReorderingPreZoomInRunnable;
240
Adam Cohen7d30a372013-07-01 17:03:59 -0700241 // Convenience/caching
242 private Matrix mTmpInvMatrix = new Matrix();
243 private float[] mTmpPoint = new float[2];
Winson Chungc9ca2982013-07-19 12:07:38 -0700244 private int[] mTmpIntPoint = new int[2];
Adam Cohen7d30a372013-07-01 17:03:59 -0700245 private Rect mTmpRect = new Rect();
246 private Rect mAltTmpRect = new Rect();
247
248 // Fling to delete
249 private int FLING_TO_DELETE_FADE_OUT_DURATION = 350;
250 private float FLING_TO_DELETE_FRICTION = 0.035f;
251 // The degrees specifies how much deviation from the up vector to still consider a fling "up"
252 private float FLING_TO_DELETE_MAX_FLING_DEGREES = 65f;
253 protected int mFlingToDeleteThresholdVelocity = -1400;
254 // Drag to delete
255 private boolean mDeferringForDelete = false;
256 private int DELETE_SLIDE_IN_SIDE_PAGE_DURATION = 250;
257 private int DRAG_TO_DELETE_FADE_OUT_DURATION = 350;
258
259 // Drop to delete
260 private View mDeleteDropTarget;
261
Adam Cohen7d30a372013-07-01 17:03:59 -0700262 // Bouncer
263 private boolean mTopAlignPageWhenShrinkingForBouncer = false;
Winson Chungb44b5242011-06-13 11:32:14 -0700264
John Spurlock77e1f472013-09-11 10:09:51 -0400265 protected final Rect mInsets = new Rect();
266
Winson Chung86f77532010-08-24 11:08:22 -0700267 public interface PageSwitchListener {
268 void onPageSwitch(View newPage, int newPageIndex);
Winson Chung321e9ee2010-08-09 13:37:56 -0700269 }
270
Winson Chung321e9ee2010-08-09 13:37:56 -0700271 public PagedView(Context context) {
272 this(context, null);
273 }
274
275 public PagedView(Context context, AttributeSet attrs) {
276 this(context, attrs, 0);
277 }
278
279 public PagedView(Context context, AttributeSet attrs, int defStyle) {
280 super(context, attrs, defStyle);
Winson Chungc9ca2982013-07-19 12:07:38 -0700281
Adam Cohen9c4949e2010-10-05 12:27:22 -0700282 TypedArray a = context.obtainStyledAttributes(attrs,
283 R.styleable.PagedView, defStyle, 0);
Adam Cohen0cd0eba2013-10-28 14:22:25 -0700284
Adam Cohen9c4949e2010-10-05 12:27:22 -0700285 mPageLayoutPaddingTop = a.getDimensionPixelSize(
Winson Chung1908d072011-02-24 18:09:44 -0800286 R.styleable.PagedView_pageLayoutPaddingTop, 0);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700287 mPageLayoutPaddingBottom = a.getDimensionPixelSize(
Winson Chung1908d072011-02-24 18:09:44 -0800288 R.styleable.PagedView_pageLayoutPaddingBottom, 0);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700289 mPageLayoutPaddingLeft = a.getDimensionPixelSize(
Winson Chung1908d072011-02-24 18:09:44 -0800290 R.styleable.PagedView_pageLayoutPaddingLeft, 0);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700291 mPageLayoutPaddingRight = a.getDimensionPixelSize(
Winson Chung1908d072011-02-24 18:09:44 -0800292 R.styleable.PagedView_pageLayoutPaddingRight, 0);
Winson Chungdf4b83d2010-10-20 17:49:27 -0700293 mPageLayoutWidthGap = a.getDimensionPixelSize(
Winson Chung7d7541e2011-09-16 20:14:36 -0700294 R.styleable.PagedView_pageLayoutWidthGap, 0);
Winson Chungdf4b83d2010-10-20 17:49:27 -0700295 mPageLayoutHeightGap = a.getDimensionPixelSize(
Winson Chung7d7541e2011-09-16 20:14:36 -0700296 R.styleable.PagedView_pageLayoutHeightGap, 0);
Winson Chungd2be3812013-07-16 11:11:32 -0700297 mPageIndicatorViewId = a.getResourceId(R.styleable.PagedView_pageIndicator, -1);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700298 a.recycle();
299
Winson Chung321e9ee2010-08-09 13:37:56 -0700300 setHapticFeedbackEnabled(false);
Michael Jurka0142d492010-08-25 17:46:15 -0700301 init();
Winson Chung321e9ee2010-08-09 13:37:56 -0700302 }
303
304 /**
305 * Initializes various states for this workspace.
306 */
Michael Jurka0142d492010-08-25 17:46:15 -0700307 protected void init() {
Winson Chung86f77532010-08-24 11:08:22 -0700308 mDirtyPageContent = new ArrayList<Boolean>();
309 mDirtyPageContent.ensureCapacity(32);
Adam Cohene0f66b52010-11-23 15:06:07 -0800310 mScroller = new Scroller(getContext(), new ScrollInterpolator());
Winson Chung86f77532010-08-24 11:08:22 -0700311 mCurrentPage = 0;
Winson Chung7da10252010-10-28 16:07:04 -0700312 mCenterPagesVertically = true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700313
314 final ViewConfiguration configuration = ViewConfiguration.get(getContext());
Adam Cohen7d30a372013-07-01 17:03:59 -0700315 mTouchSlop = configuration.getScaledPagingTouchSlop();
Winson Chung321e9ee2010-08-09 13:37:56 -0700316 mPagingTouchSlop = configuration.getScaledPagingTouchSlop();
317 mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
Adam Cohenb5ba0972011-09-07 18:02:31 -0700318 mDensity = getResources().getDisplayMetrics().density;
Adam Cohen265b9a62011-12-07 14:37:18 -0800319
Adam Cohen7d30a372013-07-01 17:03:59 -0700320 // Scale the fling-to-delete threshold by the density
321 mFlingToDeleteThresholdVelocity =
322 (int) (mFlingToDeleteThresholdVelocity * mDensity);
323
Adam Cohen265b9a62011-12-07 14:37:18 -0800324 mFlingThresholdVelocity = (int) (FLING_THRESHOLD_VELOCITY * mDensity);
325 mMinFlingVelocity = (int) (MIN_FLING_VELOCITY * mDensity);
326 mMinSnapVelocity = (int) (MIN_SNAP_VELOCITY * mDensity);
Michael Jurka8b805b12012-04-18 14:23:14 -0700327 setOnHierarchyChangeListener(this);
Winson Chung321e9ee2010-08-09 13:37:56 -0700328 }
329
Winson Chungd2be3812013-07-16 11:11:32 -0700330 protected void onAttachedToWindow() {
Adam Cohen53805212013-10-01 10:39:23 -0700331 super.onAttachedToWindow();
332
Winson Chungd2be3812013-07-16 11:11:32 -0700333 // Hook up the page indicator
334 ViewGroup parent = (ViewGroup) getParent();
335 if (mPageIndicator == null && mPageIndicatorViewId > -1) {
336 mPageIndicator = (PageIndicator) parent.findViewById(mPageIndicatorViewId);
Winson Chungc58497e2013-09-03 17:48:37 -0700337 mPageIndicator.removeAllMarkers(mAllowPagedViewAnimations);
Winson Chung82dfe582013-07-26 15:07:49 -0700338
Winson Chung7819a562013-09-19 15:55:45 -0700339 ArrayList<PageIndicator.PageMarkerResources> markers =
340 new ArrayList<PageIndicator.PageMarkerResources>();
Winson Chung82dfe582013-07-26 15:07:49 -0700341 for (int i = 0; i < getChildCount(); ++i) {
342 markers.add(getPageIndicatorMarker(i));
343 }
Adam Cohenf358a4b2013-07-23 16:47:31 -0700344
Winson Chungc58497e2013-09-03 17:48:37 -0700345 mPageIndicator.addMarkers(markers, mAllowPagedViewAnimations);
Adam Cohenfbdf4272013-10-09 13:02:21 -0700346
347 OnClickListener listener = getPageIndicatorClickListener();
348 if (listener != null) {
349 mPageIndicator.setOnClickListener(listener);
350 }
Adam Cohen53805212013-10-01 10:39:23 -0700351 mPageIndicator.setContentDescription(getPageIndicatorDescription());
Winson Chungd2be3812013-07-16 11:11:32 -0700352 }
353 }
354
Adam Cohen53805212013-10-01 10:39:23 -0700355 protected String getPageIndicatorDescription() {
356 return getCurrentPageDescription();
357 }
358
359 protected OnClickListener getPageIndicatorClickListener() {
360 return null;
361 }
362
Winson Chungd2be3812013-07-16 11:11:32 -0700363 protected void onDetachedFromWindow() {
364 // Unhook the page indicator
365 mPageIndicator = null;
366 }
367
Adam Cohen7d30a372013-07-01 17:03:59 -0700368 void setDeleteDropTarget(View v) {
369 mDeleteDropTarget = v;
370 }
371
372 // Convenience methods to map points from self to parent and vice versa
373 float[] mapPointFromViewToParent(View v, float x, float y) {
374 mTmpPoint[0] = x;
375 mTmpPoint[1] = y;
376 v.getMatrix().mapPoints(mTmpPoint);
377 mTmpPoint[0] += v.getLeft();
378 mTmpPoint[1] += v.getTop();
379 return mTmpPoint;
380 }
381 float[] mapPointFromParentToView(View v, float x, float y) {
382 mTmpPoint[0] = x - v.getLeft();
383 mTmpPoint[1] = y - v.getTop();
384 v.getMatrix().invert(mTmpInvMatrix);
385 mTmpInvMatrix.mapPoints(mTmpPoint);
386 return mTmpPoint;
387 }
388
389 void updateDragViewTranslationDuringDrag() {
Adam Cohenf358a4b2013-07-23 16:47:31 -0700390 if (mDragView != null) {
391 float x = (mLastMotionX - mDownMotionX) + (getScrollX() - mDownScrollX) +
392 (mDragViewBaselineLeft - mDragView.getLeft());
393 float y = mLastMotionY - mDownMotionY;
394 mDragView.setTranslationX(x);
395 mDragView.setTranslationY(y);
Adam Cohen7d30a372013-07-01 17:03:59 -0700396
Adam Cohenf358a4b2013-07-23 16:47:31 -0700397 if (DEBUG) Log.d(TAG, "PagedView.updateDragViewTranslationDuringDrag(): "
398 + x + ", " + y);
399 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700400 }
401
402 public void setMinScale(float f) {
403 mMinScale = f;
Winson Chungc58497e2013-09-03 17:48:37 -0700404 mUseMinScale = true;
Adam Cohen7d30a372013-07-01 17:03:59 -0700405 requestLayout();
406 }
407
408 @Override
409 public void setScaleX(float scaleX) {
410 super.setScaleX(scaleX);
411 if (isReordering(true)) {
412 float[] p = mapPointFromParentToView(this, mParentDownMotionX, mParentDownMotionY);
413 mLastMotionX = p[0];
414 mLastMotionY = p[1];
415 updateDragViewTranslationDuringDrag();
416 }
417 }
418
419 // Convenience methods to get the actual width/height of the PagedView (since it is measured
420 // to be larger to account for the minimum possible scale)
421 int getViewportWidth() {
422 return mViewport.width();
423 }
424 int getViewportHeight() {
425 return mViewport.height();
426 }
427
428 // Convenience methods to get the offset ASSUMING that we are centering the pages in the
429 // PagedView both horizontally and vertically
430 int getViewportOffsetX() {
431 return (getMeasuredWidth() - getViewportWidth()) / 2;
432 }
433
434 int getViewportOffsetY() {
435 return (getMeasuredHeight() - getViewportHeight()) / 2;
436 }
437
Adam Cohenedb40762013-07-18 16:45:45 -0700438 PageIndicator getPageIndicator() {
439 return mPageIndicator;
440 }
Winson Chung7819a562013-09-19 15:55:45 -0700441 protected PageIndicator.PageMarkerResources getPageIndicatorMarker(int pageIndex) {
442 return new PageIndicator.PageMarkerResources();
Winson Chung82dfe582013-07-26 15:07:49 -0700443 }
Adam Cohenedb40762013-07-18 16:45:45 -0700444
Winson Chung86f77532010-08-24 11:08:22 -0700445 public void setPageSwitchListener(PageSwitchListener pageSwitchListener) {
446 mPageSwitchListener = pageSwitchListener;
447 if (mPageSwitchListener != null) {
448 mPageSwitchListener.onPageSwitch(getPageAt(mCurrentPage), mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700449 }
450 }
451
452 /**
Winson Chung52aee602013-01-30 12:01:02 -0800453 * Note: this is a reimplementation of View.isLayoutRtl() since that is currently hidden api.
454 */
455 public boolean isLayoutRtl() {
456 return (getLayoutDirection() == LAYOUT_DIRECTION_RTL);
457 }
458
459 /**
Winson Chungf0ea4d32011-06-06 14:27:16 -0700460 * Called by subclasses to mark that data is ready, and that we can begin loading and laying
461 * out pages.
462 */
463 protected void setDataIsReady() {
464 mIsDataReady = true;
465 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700466
Winson Chungf0ea4d32011-06-06 14:27:16 -0700467 protected boolean isDataReady() {
468 return mIsDataReady;
469 }
470
471 /**
Winson Chung86f77532010-08-24 11:08:22 -0700472 * Returns the index of the currently displayed page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700473 *
Winson Chung86f77532010-08-24 11:08:22 -0700474 * @return The index of the currently displayed page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700475 */
Winson Chung86f77532010-08-24 11:08:22 -0700476 int getCurrentPage() {
477 return mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700478 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700479
Winson Chung360e63f2012-04-27 13:48:05 -0700480 int getNextPage() {
481 return (mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage;
482 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700483
Winson Chung86f77532010-08-24 11:08:22 -0700484 int getPageCount() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700485 return getChildCount();
486 }
487
Winson Chung86f77532010-08-24 11:08:22 -0700488 View getPageAt(int index) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700489 return getChildAt(index);
490 }
491
Adam Cohenae4f1552011-10-20 00:15:42 -0700492 protected int indexToPage(int index) {
493 return index;
494 }
495
Winson Chung321e9ee2010-08-09 13:37:56 -0700496 /**
Winson Chungbbc60d82010-11-11 16:34:41 -0800497 * Updates the scroll of the current page immediately to its final scroll position. We use this
498 * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of
499 * the previous tab page.
500 */
501 protected void updateCurrentPageScroll() {
Adam Cohen0ffac432013-07-10 11:19:26 -0700502 // If the current page is invalid, just reset the scroll position to zero
503 int newX = 0;
504 if (0 <= mCurrentPage && mCurrentPage < getPageCount()) {
Adam Cohenedb40762013-07-18 16:45:45 -0700505 newX = getScrollForPage(mCurrentPage);
Adam Cohen0ffac432013-07-10 11:19:26 -0700506 }
Winson Chungbbc60d82010-11-11 16:34:41 -0800507 scrollTo(newX, 0);
508 mScroller.setFinalX(newX);
Adam Cohen4fe4c932013-10-28 16:02:34 -0700509 forceFinishScroller();
Winson Chungbbc60d82010-11-11 16:34:41 -0800510 }
511
512 /**
Chet Haasebc2f0822012-10-26 17:59:53 -0700513 * Called during AllApps/Home transitions to avoid unnecessary work. When that other animation
Adam Cohen4fe4c932013-10-28 16:02:34 -0700514 * {@link #updateCurrentPageScroll()} should be called, to correctly set the final state and
515 * re-enable scrolling.
Chet Haasebc2f0822012-10-26 17:59:53 -0700516 */
Adam Cohen4fe4c932013-10-28 16:02:34 -0700517 void stopScrolling() {
518 mCurrentPage = mNextPage;
519 forceFinishScroller();
Chet Haasebc2f0822012-10-26 17:59:53 -0700520 }
521
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700522 private void abortScrollerAnimation(boolean resetNextPage) {
Adam Cohen4fe4c932013-10-28 16:02:34 -0700523 mScroller.abortAnimation();
524 // We need to clean up the next page here to avoid computeScrollHelper from
525 // updating current page on the pass.
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700526 if (resetNextPage) {
527 mNextPage = INVALID_PAGE;
528 }
Chet Haasebc2f0822012-10-26 17:59:53 -0700529 }
Adam Cohen4fe4c932013-10-28 16:02:34 -0700530
531 private void forceFinishScroller() {
532 mScroller.forceFinished(true);
533 // We need to clean up the next page here to avoid computeScrollHelper from
534 // updating current page on the pass.
535 mNextPage = INVALID_PAGE;
536 }
537
Chet Haasebc2f0822012-10-26 17:59:53 -0700538 /**
Winson Chung86f77532010-08-24 11:08:22 -0700539 * Sets the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700540 */
Winson Chung86f77532010-08-24 11:08:22 -0700541 void setCurrentPage(int currentPage) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800542 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700543 abortScrollerAnimation(true);
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800544 }
Michael Jurkad3ef3062010-11-23 16:23:58 -0800545 // don't introduce any checks like mCurrentPage == currentPage here-- if we change the
546 // the default
547 if (getChildCount() == 0) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800548 return;
549 }
Adam Cohene61a9a22013-06-11 15:45:31 -0700550 mForceScreenScrolled = true;
Winson Chung86f77532010-08-24 11:08:22 -0700551 mCurrentPage = Math.max(0, Math.min(currentPage, getPageCount() - 1));
Winson Chung181c3dc2013-07-17 15:36:20 -0700552 updateCurrentPageScroll();
Winson Chung86f77532010-08-24 11:08:22 -0700553 notifyPageSwitchListener();
Winson Chunga12a2502010-12-20 14:41:35 -0800554 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -0700555 }
556
Winson Chung8c87cd82013-07-23 16:20:10 -0700557 /**
558 * The restore page will be set in place of the current page at the next (likely first)
559 * layout.
560 */
561 void setRestorePage(int restorePage) {
562 mRestorePage = restorePage;
563 }
564
Michael Jurka0142d492010-08-25 17:46:15 -0700565 protected void notifyPageSwitchListener() {
Winson Chung86f77532010-08-24 11:08:22 -0700566 if (mPageSwitchListener != null) {
567 mPageSwitchListener.onPageSwitch(getPageAt(mCurrentPage), mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700568 }
Winson Chungd2be3812013-07-16 11:11:32 -0700569
570 // Update the page indicator (when we aren't reordering)
571 if (mPageIndicator != null && !isReordering(false)) {
572 mPageIndicator.setActiveMarker(getNextPage());
573 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700574 }
Michael Jurkace7e05f2011-02-01 22:02:35 -0800575 protected void pageBeginMoving() {
Michael Jurkad74c9842011-07-10 12:44:21 -0700576 if (!mIsPageMoving) {
577 mIsPageMoving = true;
578 onPageBeginMoving();
579 }
Patrick Dubroy1262e362010-10-06 15:49:50 -0700580 }
581
Michael Jurkace7e05f2011-02-01 22:02:35 -0800582 protected void pageEndMoving() {
Michael Jurkad74c9842011-07-10 12:44:21 -0700583 if (mIsPageMoving) {
584 mIsPageMoving = false;
585 onPageEndMoving();
586 }
Michael Jurka0142d492010-08-25 17:46:15 -0700587 }
588
Adam Cohen26976d92011-03-22 15:33:33 -0700589 protected boolean isPageMoving() {
590 return mIsPageMoving;
591 }
592
Michael Jurka0142d492010-08-25 17:46:15 -0700593 // a method that subclasses can override to add behavior
Patrick Dubroy1262e362010-10-06 15:49:50 -0700594 protected void onPageBeginMoving() {
595 }
596
597 // a method that subclasses can override to add behavior
598 protected void onPageEndMoving() {
Michael Jurka0142d492010-08-25 17:46:15 -0700599 }
600
Winson Chung321e9ee2010-08-09 13:37:56 -0700601 /**
Winson Chung86f77532010-08-24 11:08:22 -0700602 * Registers the specified listener on each page contained in this workspace.
Winson Chung321e9ee2010-08-09 13:37:56 -0700603 *
604 * @param l The listener used to respond to long clicks.
605 */
606 @Override
607 public void setOnLongClickListener(OnLongClickListener l) {
608 mLongClickListener = l;
Winson Chung86f77532010-08-24 11:08:22 -0700609 final int count = getPageCount();
Winson Chung321e9ee2010-08-09 13:37:56 -0700610 for (int i = 0; i < count; i++) {
Winson Chung86f77532010-08-24 11:08:22 -0700611 getPageAt(i).setOnLongClickListener(l);
Winson Chung321e9ee2010-08-09 13:37:56 -0700612 }
Adam Cohen1697b792013-09-17 19:08:21 -0700613 super.setOnLongClickListener(l);
Winson Chung321e9ee2010-08-09 13:37:56 -0700614 }
615
616 @Override
Adam Cohen68d73932010-11-15 10:50:58 -0800617 public void scrollBy(int x, int y) {
Michael Jurka8b805b12012-04-18 14:23:14 -0700618 scrollTo(mUnboundedScrollX + x, getScrollY() + y);
Adam Cohen68d73932010-11-15 10:50:58 -0800619 }
620
621 @Override
Michael Jurka0142d492010-08-25 17:46:15 -0700622 public void scrollTo(int x, int y) {
Adam Cohenf358a4b2013-07-23 16:47:31 -0700623 // In free scroll mode, we clamp the scrollX
624 if (mFreeScroll) {
625 x = Math.min(x, mFreeScrollMaxScrollX);
626 x = Math.max(x, mFreeScrollMinScrollX);
627 }
628
Adam Cohen0ffac432013-07-10 11:19:26 -0700629 final boolean isRtl = isLayoutRtl();
Adam Cohen68d73932010-11-15 10:50:58 -0800630 mUnboundedScrollX = x;
631
Adam Cohen0ffac432013-07-10 11:19:26 -0700632 boolean isXBeforeFirstPage = isRtl ? (x > mMaxScrollX) : (x < 0);
633 boolean isXAfterLastPage = isRtl ? (x < 0) : (x > mMaxScrollX);
634 if (isXBeforeFirstPage) {
Adam Cohen68d73932010-11-15 10:50:58 -0800635 super.scrollTo(0, y);
636 if (mAllowOverScroll) {
Adam Cohen0ffac432013-07-10 11:19:26 -0700637 if (isRtl) {
638 overScroll(x - mMaxScrollX);
639 } else {
640 overScroll(x);
641 }
Adam Cohen68d73932010-11-15 10:50:58 -0800642 }
Adam Cohen0ffac432013-07-10 11:19:26 -0700643 } else if (isXAfterLastPage) {
Adam Cohen68d73932010-11-15 10:50:58 -0800644 super.scrollTo(mMaxScrollX, y);
645 if (mAllowOverScroll) {
Adam Cohen0ffac432013-07-10 11:19:26 -0700646 if (isRtl) {
647 overScroll(x);
648 } else {
649 overScroll(x - mMaxScrollX);
650 }
Adam Cohen68d73932010-11-15 10:50:58 -0800651 }
652 } else {
Adam Cohenebea84d2011-11-09 17:20:41 -0800653 mOverScrollX = x;
Adam Cohen68d73932010-11-15 10:50:58 -0800654 super.scrollTo(x, y);
655 }
656
Michael Jurka0142d492010-08-25 17:46:15 -0700657 mTouchX = x;
658 mSmoothingTime = System.nanoTime() / NANOTIME_DIV;
Adam Cohen7d30a372013-07-01 17:03:59 -0700659
660 // Update the last motion events when scrolling
661 if (isReordering(true)) {
662 float[] p = mapPointFromParentToView(this, mParentDownMotionX, mParentDownMotionY);
663 mLastMotionX = p[0];
664 mLastMotionY = p[1];
665 updateDragViewTranslationDuringDrag();
666 }
Michael Jurka0142d492010-08-25 17:46:15 -0700667 }
668
Adam Cohen53805212013-10-01 10:39:23 -0700669 private void sendScrollAccessibilityEvent() {
670 AccessibilityManager am =
671 (AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
672 if (am.isEnabled()) {
673 AccessibilityEvent ev =
674 AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_SCROLLED);
Adam Cohen53805212013-10-01 10:39:23 -0700675 ev.setItemCount(getChildCount());
676 ev.setFromIndex(mCurrentPage);
Adam Cohen53805212013-10-01 10:39:23 -0700677
Alan Viverette254139a2013-10-08 13:13:46 -0700678 final int action;
Adam Cohen53805212013-10-01 10:39:23 -0700679 if (getNextPage() >= mCurrentPage) {
680 action = AccessibilityNodeInfo.ACTION_SCROLL_FORWARD;
681 } else {
682 action = AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD;
683 }
684
685 ev.setAction(action);
686 sendAccessibilityEventUnchecked(ev);
687 }
688 }
689
Michael Jurka0142d492010-08-25 17:46:15 -0700690 // we moved this functionality to a helper function so SmoothPagedView can reuse it
691 protected boolean computeScrollHelper() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700692 if (mScroller.computeScrollOffset()) {
Winson Chung557d6ed2011-07-08 15:34:52 -0700693 // Don't bother scrolling if the page does not need to be moved
Michael Jurka8b805b12012-04-18 14:23:14 -0700694 if (getScrollX() != mScroller.getCurrX()
695 || getScrollY() != mScroller.getCurrY()
Michael Jurkab06d95f2012-04-02 06:26:53 -0700696 || mOverScrollX != mScroller.getCurrX()) {
Adam Cohenf358a4b2013-07-23 16:47:31 -0700697 float scaleX = mFreeScroll ? getScaleX() : 1f;
698 int scrollX = (int) (mScroller.getCurrX() * (1 / scaleX));
699 scrollTo(scrollX, mScroller.getCurrY());
Winson Chung557d6ed2011-07-08 15:34:52 -0700700 }
Michael Jurka0142d492010-08-25 17:46:15 -0700701 invalidate();
702 return true;
Winson Chung86f77532010-08-24 11:08:22 -0700703 } else if (mNextPage != INVALID_PAGE) {
Adam Cohen53805212013-10-01 10:39:23 -0700704 sendScrollAccessibilityEvent();
705
Winson Chung86f77532010-08-24 11:08:22 -0700706 mCurrentPage = Math.max(0, Math.min(mNextPage, getPageCount() - 1));
Winson Chung86f77532010-08-24 11:08:22 -0700707 mNextPage = INVALID_PAGE;
Michael Jurka0142d492010-08-25 17:46:15 -0700708 notifyPageSwitchListener();
Winson Chungb44b5242011-06-13 11:32:14 -0700709
Winson Chung9c0565f2013-07-19 13:49:06 -0700710 // Load the associated pages if necessary
711 if (mDeferLoadAssociatedPagesUntilScrollCompletes) {
712 loadAssociatedPages(mCurrentPage);
713 mDeferLoadAssociatedPagesUntilScrollCompletes = false;
714 }
715
Adam Cohen73aa9752010-11-24 16:26:58 -0800716 // We don't want to trigger a page end moving unless the page has settled
717 // and the user has stopped scrolling
718 if (mTouchState == TOUCH_STATE_REST) {
719 pageEndMoving();
720 }
Winson Chungc27d1bb2011-09-29 12:07:42 -0700721
Adam Cohen7d30a372013-07-01 17:03:59 -0700722 onPostReorderingAnimationCompleted();
Adam Cohen53805212013-10-01 10:39:23 -0700723 AccessibilityManager am = (AccessibilityManager)
Adam Cohen0ffac432013-07-10 11:19:26 -0700724 getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
Adam Cohen53805212013-10-01 10:39:23 -0700725 if (am.isEnabled()) {
726 // Notify the user when the page changes
727 announceForAccessibility(getCurrentPageDescription());
Adam Cohen0ffac432013-07-10 11:19:26 -0700728 }
Michael Jurka0142d492010-08-25 17:46:15 -0700729 return true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700730 }
Michael Jurka0142d492010-08-25 17:46:15 -0700731 return false;
732 }
733
734 @Override
735 public void computeScroll() {
736 computeScrollHelper();
Winson Chung321e9ee2010-08-09 13:37:56 -0700737 }
738
Adam Cohen7d30a372013-07-01 17:03:59 -0700739 protected boolean shouldSetTopAlignedPivotForWidget(int childIndex) {
740 return mTopAlignPageWhenShrinkingForBouncer;
741 }
742
Adam Cohen96d30a12013-07-16 18:13:21 -0700743 public static class LayoutParams extends ViewGroup.LayoutParams {
744 public boolean isFullScreenPage = false;
745
746 /**
747 * {@inheritDoc}
748 */
749 public LayoutParams(int width, int height) {
750 super(width, height);
751 }
752
753 public LayoutParams(ViewGroup.LayoutParams source) {
754 super(source);
755 }
756 }
757
758 protected LayoutParams generateDefaultLayoutParams() {
759 return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
760 }
761
Adam Cohenedb40762013-07-18 16:45:45 -0700762 public void addFullScreenPage(View page) {
Adam Cohen96d30a12013-07-16 18:13:21 -0700763 LayoutParams lp = generateDefaultLayoutParams();
764 lp.isFullScreenPage = true;
765 super.addView(page, 0, lp);
766 }
767
Adam Cohen410f3cd2013-09-22 12:09:32 -0700768 public int getNormalChildHeight() {
769 return mNormalChildHeight;
770 }
771
Winson Chung321e9ee2010-08-09 13:37:56 -0700772 @Override
773 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
Adam Cohendcd297f2013-06-18 13:13:40 -0700774 if (!mIsDataReady || getChildCount() == 0) {
Winson Chungf0ea4d32011-06-06 14:27:16 -0700775 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
776 return;
777 }
778
Adam Cohen7d30a372013-07-01 17:03:59 -0700779 // We measure the dimensions of the PagedView to be larger than the pages so that when we
780 // zoom out (and scale down), the view is still contained in the parent
Adam Cohen7d30a372013-07-01 17:03:59 -0700781 int widthMode = MeasureSpec.getMode(widthMeasureSpec);
782 int widthSize = MeasureSpec.getSize(widthMeasureSpec);
783 int heightMode = MeasureSpec.getMode(heightMeasureSpec);
Winson Chung8aad6102012-05-11 16:27:49 -0700784 int heightSize = MeasureSpec.getSize(heightMeasureSpec);
Adam Cohen7d30a372013-07-01 17:03:59 -0700785 // NOTE: We multiply by 1.5f to account for the fact that depending on the offset of the
786 // viewport, we can be at most one and a half screens offset once we scale down
787 DisplayMetrics dm = getResources().getDisplayMetrics();
Adam Cohendbdff6b2013-09-18 19:09:15 -0700788 int maxSize = Math.max(dm.widthPixels, dm.heightPixels + mInsets.top + mInsets.bottom);
Adam Cohen410f3cd2013-09-22 12:09:32 -0700789
Winson Chungc58497e2013-09-03 17:48:37 -0700790 int parentWidthSize, parentHeightSize;
791 int scaledWidthSize, scaledHeightSize;
792 if (mUseMinScale) {
793 parentWidthSize = (int) (1.5f * maxSize);
794 parentHeightSize = maxSize;
795 scaledWidthSize = (int) (parentWidthSize / mMinScale);
796 scaledHeightSize = (int) (parentHeightSize / mMinScale);
797 } else {
798 scaledWidthSize = widthSize;
799 scaledHeightSize = heightSize;
800 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700801 mViewport.set(0, 0, widthSize, heightSize);
802
803 if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
804 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
805 return;
Winson Chung321e9ee2010-08-09 13:37:56 -0700806 }
807
Winson Chung8aad6102012-05-11 16:27:49 -0700808 // Return early if we aren't given a proper dimension
809 if (widthSize <= 0 || heightSize <= 0) {
810 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
811 return;
812 }
813
Adam Lesinski6b879f02010-11-04 16:15:23 -0700814 /* Allow the height to be set as WRAP_CONTENT. This allows the particular case
815 * of the All apps view on XLarge displays to not take up more space then it needs. Width
816 * is still not allowed to be set as WRAP_CONTENT since many parts of the code expect
817 * each page to have the same width.
818 */
Michael Jurka8b805b12012-04-18 14:23:14 -0700819 final int verticalPadding = getPaddingTop() + getPaddingBottom();
820 final int horizontalPadding = getPaddingLeft() + getPaddingRight();
Winson Chung321e9ee2010-08-09 13:37:56 -0700821
822 // The children are given the same width and height as the workspace
Michael Jurka5f1c5092010-09-03 14:15:02 -0700823 // unless they were set to WRAP_CONTENT
Winson Chung785d2eb2011-04-14 16:08:02 -0700824 if (DEBUG) Log.d(TAG, "PagedView.onMeasure(): " + widthSize + ", " + heightSize);
Adam Cohen7d30a372013-07-01 17:03:59 -0700825 if (DEBUG) Log.d(TAG, "PagedView.scaledSize: " + scaledWidthSize + ", " + scaledHeightSize);
826 if (DEBUG) Log.d(TAG, "PagedView.parentSize: " + parentWidthSize + ", " + parentHeightSize);
827 if (DEBUG) Log.d(TAG, "PagedView.horizontalPadding: " + horizontalPadding);
828 if (DEBUG) Log.d(TAG, "PagedView.verticalPadding: " + verticalPadding);
Winson Chung321e9ee2010-08-09 13:37:56 -0700829 final int childCount = getChildCount();
830 for (int i = 0; i < childCount; i++) {
Michael Jurka5f1c5092010-09-03 14:15:02 -0700831 // disallowing padding in paged view (just pass 0)
Adam Cohen22f823d2011-09-01 17:22:18 -0700832 final View child = getPageAt(i);
Vladimir Marko2824b072013-10-04 16:42:17 +0100833 if (child.getVisibility() != GONE) {
834 final LayoutParams lp = (LayoutParams) child.getLayoutParams();
Michael Jurka5f1c5092010-09-03 14:15:02 -0700835
Vladimir Marko2824b072013-10-04 16:42:17 +0100836 int childWidthMode;
837 int childHeightMode;
838 int childWidth;
839 int childHeight;
Adam Cohen96d30a12013-07-16 18:13:21 -0700840
Vladimir Marko2824b072013-10-04 16:42:17 +0100841 if (!lp.isFullScreenPage) {
842 if (lp.width == LayoutParams.WRAP_CONTENT) {
843 childWidthMode = MeasureSpec.AT_MOST;
844 } else {
845 childWidthMode = MeasureSpec.EXACTLY;
846 }
847
848 if (lp.height == LayoutParams.WRAP_CONTENT) {
849 childHeightMode = MeasureSpec.AT_MOST;
850 } else {
851 childHeightMode = MeasureSpec.EXACTLY;
852 }
853
854 childWidth = widthSize - horizontalPadding;
855 childHeight = heightSize - verticalPadding - mInsets.top - mInsets.bottom;
856 mNormalChildHeight = childHeight;
857
Adam Cohen96d30a12013-07-16 18:13:21 -0700858 } else {
859 childWidthMode = MeasureSpec.EXACTLY;
Adam Cohen96d30a12013-07-16 18:13:21 -0700860 childHeightMode = MeasureSpec.EXACTLY;
Vladimir Marko2824b072013-10-04 16:42:17 +0100861
862 if (mUseMinScale) {
863 childWidth = getViewportWidth();
864 childHeight = getViewportHeight();
865 } else {
866 childWidth = widthSize - getPaddingLeft() - getPaddingRight();
867 childHeight = heightSize - getPaddingTop() - getPaddingBottom();
868 }
Adam Cohen96d30a12013-07-16 18:13:21 -0700869 }
870
Vladimir Marko2824b072013-10-04 16:42:17 +0100871 final int childWidthMeasureSpec =
872 MeasureSpec.makeMeasureSpec(childWidth, childWidthMode);
873 final int childHeightMeasureSpec =
874 MeasureSpec.makeMeasureSpec(childHeight, childHeightMode);
875 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700876 }
Adam Lesinski6b879f02010-11-04 16:15:23 -0700877 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700878 setMeasuredDimension(scaledWidthSize, scaledHeightSize);
Adam Cohen60b07122011-11-14 17:26:06 -0800879 }
880
Winson Chung321e9ee2010-08-09 13:37:56 -0700881 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700882 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
Adam Cohendcd297f2013-06-18 13:13:40 -0700883 if (!mIsDataReady || getChildCount() == 0) {
Winson Chungf0ea4d32011-06-06 14:27:16 -0700884 return;
885 }
886
Winson Chung785d2eb2011-04-14 16:08:02 -0700887 if (DEBUG) Log.d(TAG, "PagedView.onLayout()");
Winson Chung321e9ee2010-08-09 13:37:56 -0700888 final int childCount = getChildCount();
Winson Chung321e9ee2010-08-09 13:37:56 -0700889
Adam Cohenedb40762013-07-18 16:45:45 -0700890 int screenWidth = getViewportWidth();
891
Adam Cohen7d30a372013-07-01 17:03:59 -0700892 int offsetX = getViewportOffsetX();
893 int offsetY = getViewportOffsetY();
894
895 // Update the viewport offsets
896 mViewport.offset(offsetX, offsetY);
897
Adam Cohen0ffac432013-07-10 11:19:26 -0700898 final boolean isRtl = isLayoutRtl();
899
900 final int startIndex = isRtl ? childCount - 1 : 0;
901 final int endIndex = isRtl ? -1 : childCount;
902 final int delta = isRtl ? -1 : 1;
903
Adam Cohen7d30a372013-07-01 17:03:59 -0700904 int verticalPadding = getPaddingTop() + getPaddingBottom();
Adam Cohenedb40762013-07-18 16:45:45 -0700905
Michael Jurka8fd3adc2013-10-16 13:50:24 -0700906 int childLeft = offsetX + (screenWidth - getChildWidth(startIndex)) / 2;
Adam Cohenedb40762013-07-18 16:45:45 -0700907 if (mPageScrolls == null || getChildCount() != mChildCountOnLastLayout) {
908 mPageScrolls = new int[getChildCount()];
909 }
910
Adam Cohen0ffac432013-07-10 11:19:26 -0700911 for (int i = startIndex; i != endIndex; i += delta) {
Adam Cohen22f823d2011-09-01 17:22:18 -0700912 final View child = getPageAt(i);
Winson Chung321e9ee2010-08-09 13:37:56 -0700913 if (child.getVisibility() != View.GONE) {
Vladimir Marko2824b072013-10-04 16:42:17 +0100914 LayoutParams lp = (LayoutParams) child.getLayoutParams();
915 int childTop;
916 if (lp.isFullScreenPage) {
917 childTop = offsetY;
918 } else {
919 childTop = offsetY + getPaddingTop() + mInsets.top;
920 if (mCenterPagesVertically) {
921 childTop += (getViewportHeight() - mInsets.top - mInsets.bottom - verticalPadding - child.getMeasuredHeight()) / 2;
922 }
923 }
924
Adam Cohen96d30a12013-07-16 18:13:21 -0700925 final int childWidth = child.getMeasuredWidth();
Adam Lesinski6b879f02010-11-04 16:15:23 -0700926 final int childHeight = child.getMeasuredHeight();
Michael Jurkad3ef3062010-11-23 16:23:58 -0800927
Winson Chung785d2eb2011-04-14 16:08:02 -0700928 if (DEBUG) Log.d(TAG, "\tlayout-child" + i + ": " + childLeft + ", " + childTop);
Adam Lesinski6b879f02010-11-04 16:15:23 -0700929 child.layout(childLeft, childTop,
Michael Jurkad3ef3062010-11-23 16:23:58 -0800930 childLeft + child.getMeasuredWidth(), childTop + childHeight);
Adam Cohenedb40762013-07-18 16:45:45 -0700931
932 // We assume the left and right padding are equal, and hence center the pages
933 // horizontally
Adam Cohen6ad0e7d2013-07-24 13:55:41 -0700934 int scrollOffset = (getViewportWidth() - childWidth) / 2;
Adam Cohenedb40762013-07-18 16:45:45 -0700935 mPageScrolls[i] = childLeft - scrollOffset - offsetX;
936
Adam Cohen6ad0e7d2013-07-24 13:55:41 -0700937 if (i != endIndex - delta) {
Adam Cohenaf9b0e52013-09-23 19:27:38 -0700938 childLeft += childWidth + scrollOffset;
Adam Cohen6ad0e7d2013-07-24 13:55:41 -0700939 int nextScrollOffset = (getViewportWidth() - getChildWidth(i + delta)) / 2;
Adam Cohenaf9b0e52013-09-23 19:27:38 -0700940 childLeft += nextScrollOffset;
Adam Cohen6ad0e7d2013-07-24 13:55:41 -0700941 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700942 }
943 }
Winson Chungc3665fa2011-09-14 17:56:27 -0700944
945 if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < getChildCount()) {
946 setHorizontalScrollBarEnabled(false);
Michael Jurkadd6c0912012-01-16 06:46:20 -0800947 updateCurrentPageScroll();
Winson Chungc3665fa2011-09-14 17:56:27 -0700948 setHorizontalScrollBarEnabled(true);
949 mFirstLayout = false;
950 }
Adam Cohenf698c6e2013-07-17 18:44:25 -0700951
952 if (childCount > 0) {
953 final int index = isLayoutRtl() ? 0 : childCount - 1;
Adam Cohenedb40762013-07-18 16:45:45 -0700954 mMaxScrollX = getScrollForPage(index);
Adam Cohenf698c6e2013-07-17 18:44:25 -0700955 } else {
956 mMaxScrollX = 0;
957 }
958
959 if (mScroller.isFinished() && mChildCountOnLastLayout != getChildCount() &&
960 !mDeferringForDelete) {
Adam Cohen21cd0022013-10-09 18:57:02 -0700961 if (mRestorePage != INVALID_RESTORE_PAGE) {
Winson Chung8c87cd82013-07-23 16:20:10 -0700962 setCurrentPage(mRestorePage);
Adam Cohen21cd0022013-10-09 18:57:02 -0700963 mRestorePage = INVALID_RESTORE_PAGE;
Winson Chung8c87cd82013-07-23 16:20:10 -0700964 } else {
965 setCurrentPage(getNextPage());
966 }
Adam Cohenf698c6e2013-07-17 18:44:25 -0700967 }
968 mChildCountOnLastLayout = getChildCount();
Adam Cohenf358a4b2013-07-23 16:47:31 -0700969
970 if (isReordering(true)) {
971 updateDragViewTranslationDuringDrag();
972 }
Winson Chunge3193b92010-09-10 11:44:42 -0700973 }
974
Adam Cohenf34bab52010-09-30 14:11:56 -0700975 protected void screenScrolled(int screenCenter) {
Michael Jurka869390b2012-05-06 15:55:19 -0700976 boolean isInOverscroll = mOverScrollX < 0 || mOverScrollX > mMaxScrollX;
977
978 if (mFadeInAdjacentScreens && !isInOverscroll) {
Adam Cohen73894962011-10-31 13:17:17 -0700979 for (int i = 0; i < getChildCount(); i++) {
980 View child = getChildAt(i);
981 if (child != null) {
982 float scrollProgress = getScrollProgress(screenCenter, child, i);
983 float alpha = 1 - Math.abs(scrollProgress);
Michael Jurka7372c592012-01-16 04:21:35 -0800984 child.setAlpha(alpha);
Adam Cohen73894962011-10-31 13:17:17 -0700985 }
986 }
987 invalidate();
988 }
Adam Cohenf34bab52010-09-30 14:11:56 -0700989 }
990
Winson Chungc58497e2013-09-03 17:48:37 -0700991 protected void enablePagedViewAnimations() {
992 mAllowPagedViewAnimations = true;
993
994 }
995 protected void disablePagedViewAnimations() {
996 mAllowPagedViewAnimations = false;
997 }
998
Winson Chunge3193b92010-09-10 11:44:42 -0700999 @Override
Michael Jurka8b805b12012-04-18 14:23:14 -07001000 public void onChildViewAdded(View parent, View child) {
Winson Chungd2be3812013-07-16 11:11:32 -07001001 // Update the page indicator, we don't update the page indicator as we
1002 // add/remove pages
1003 if (mPageIndicator != null && !isReordering(false)) {
Winson Chung82dfe582013-07-26 15:07:49 -07001004 int pageIndex = indexOfChild(child);
Winson Chung7819a562013-09-19 15:55:45 -07001005 mPageIndicator.addMarker(pageIndex,
1006 getPageIndicatorMarker(pageIndex),
Winson Chungc58497e2013-09-03 17:48:37 -07001007 mAllowPagedViewAnimations);
Winson Chungd2be3812013-07-16 11:11:32 -07001008 }
1009
Adam Cohen2591f6a2011-10-25 14:36:40 -07001010 // This ensures that when children are added, they get the correct transforms / alphas
1011 // in accordance with any scroll effects.
1012 mForceScreenScrolled = true;
Adam Cohen7a9e58a2013-10-01 18:02:13 -07001013 updateFreescrollBounds();
Adam Cohen2591f6a2011-10-25 14:36:40 -07001014 invalidate();
1015 }
1016
Michael Jurka8b805b12012-04-18 14:23:14 -07001017 @Override
1018 public void onChildViewRemoved(View parent, View child) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001019 mForceScreenScrolled = true;
Adam Cohen7a9e58a2013-10-01 18:02:13 -07001020 updateFreescrollBounds();
Adam Cohen7d30a372013-07-01 17:03:59 -07001021 invalidate();
Michael Jurka8b805b12012-04-18 14:23:14 -07001022 }
1023
Winson Chungd2be3812013-07-16 11:11:32 -07001024 private void removeMarkerForView(int index) {
1025 // Update the page indicator, we don't update the page indicator as we
1026 // add/remove pages
1027 if (mPageIndicator != null && !isReordering(false)) {
Winson Chungc58497e2013-09-03 17:48:37 -07001028 mPageIndicator.removeMarker(index, mAllowPagedViewAnimations);
Winson Chungd2be3812013-07-16 11:11:32 -07001029 }
1030 }
1031
1032 @Override
1033 public void removeView(View v) {
1034 // XXX: We should find a better way to hook into this before the view
1035 // gets removed form its parent...
1036 removeMarkerForView(indexOfChild(v));
1037 super.removeView(v);
1038 }
1039 @Override
1040 public void removeViewInLayout(View v) {
1041 // XXX: We should find a better way to hook into this before the view
1042 // gets removed form its parent...
1043 removeMarkerForView(indexOfChild(v));
1044 super.removeViewInLayout(v);
1045 }
1046 @Override
1047 public void removeViewAt(int index) {
1048 // XXX: We should find a better way to hook into this before the view
1049 // gets removed form its parent...
1050 removeViewAt(index);
1051 super.removeViewAt(index);
1052 }
1053 @Override
1054 public void removeAllViewsInLayout() {
1055 // Update the page indicator, we don't update the page indicator as we
1056 // add/remove pages
1057 if (mPageIndicator != null) {
Winson Chungc58497e2013-09-03 17:48:37 -07001058 mPageIndicator.removeAllMarkers(mAllowPagedViewAnimations);
Winson Chungd2be3812013-07-16 11:11:32 -07001059 }
1060
1061 super.removeAllViewsInLayout();
1062 }
1063
Adam Cohen73894962011-10-31 13:17:17 -07001064 protected int getChildOffset(int index) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001065 if (index < 0 || index > getChildCount() - 1) return 0;
1066
Adam Cohenf698c6e2013-07-17 18:44:25 -07001067 int offset = getPageAt(index).getLeft() - getViewportOffsetX();
Adam Cohen73894962011-10-31 13:17:17 -07001068
Adam Cohenf698c6e2013-07-17 18:44:25 -07001069 return offset;
Adam Cohen73894962011-10-31 13:17:17 -07001070 }
1071
Adam Cohenf358a4b2013-07-23 16:47:31 -07001072 protected void getOverviewModePages(int[] range) {
Winson Chungc9ca2982013-07-19 12:07:38 -07001073 range[0] = 0;
Adam Cohen1f1f45d2013-10-02 09:40:18 -07001074 range[1] = Math.max(0, getChildCount() - 1);
Adam Cohen7d30a372013-07-01 17:03:59 -07001075 }
1076
Michael Jurkadde558b2011-11-09 22:09:06 -08001077 protected void getVisiblePages(int[] range) {
Michael Jurka0142d492010-08-25 17:46:15 -07001078 final int pageCount = getChildCount();
Winson Chungc9ca2982013-07-19 12:07:38 -07001079 mTmpIntPoint[0] = mTmpIntPoint[1] = 0;
Michael Jurka4ff7d792012-04-02 03:46:50 -07001080
Adam Cohenaf9b0e52013-09-23 19:27:38 -07001081 range[0] = -1;
1082 range[1] = -1;
1083
Michael Jurkac4fb9172010-09-02 17:19:20 -07001084 if (pageCount > 0) {
Winson Chungc9ca2982013-07-19 12:07:38 -07001085 int viewportWidth = getViewportWidth();
Adam Cohenaf9b0e52013-09-23 19:27:38 -07001086 int curScreen = 0;
Adam Cohen7d30a372013-07-01 17:03:59 -07001087
Adam Cohenaf9b0e52013-09-23 19:27:38 -07001088 int count = getChildCount();
1089 for (int i = 0; i < count; i++) {
1090 View currPage = getPageAt(i);
Winson Chungc9ca2982013-07-19 12:07:38 -07001091
Winson Chungc9ca2982013-07-19 12:07:38 -07001092 mTmpIntPoint[0] = 0;
Winson Chungc763c4e2013-07-19 13:49:06 -07001093 Utilities.getDescendantCoordRelativeToParent(currPage, this, mTmpIntPoint, false);
Adam Cohenaf9b0e52013-09-23 19:27:38 -07001094 if (mTmpIntPoint[0] > viewportWidth) {
1095 if (range[0] == -1) {
1096 continue;
1097 } else {
1098 break;
1099 }
1100 }
1101
Adam Cohen6a678da2013-09-24 10:58:01 -07001102 mTmpIntPoint[0] = currPage.getMeasuredWidth();
Adam Cohenaf9b0e52013-09-23 19:27:38 -07001103 Utilities.getDescendantCoordRelativeToParent(currPage, this, mTmpIntPoint, false);
1104 if (mTmpIntPoint[0] < 0) {
1105 if (range[0] == -1) {
1106 continue;
1107 } else {
1108 break;
1109 }
1110 }
1111 curScreen = i;
1112 if (range[0] < 0) {
1113 range[0] = curScreen;
Winson Chungc9ca2982013-07-19 12:07:38 -07001114 }
1115 }
Adam Cohenaf9b0e52013-09-23 19:27:38 -07001116
1117 range[1] = curScreen;
Michael Jurkadde558b2011-11-09 22:09:06 -08001118 } else {
1119 range[0] = -1;
1120 range[1] = -1;
1121 }
1122 }
1123
Michael Jurka920d7f42012-05-14 16:29:55 -07001124 protected boolean shouldDrawChild(View child) {
Adam Cohenf3434992013-09-16 16:52:59 -07001125 return child.getAlpha() > 0 && child.getVisibility() == VISIBLE;
Michael Jurka920d7f42012-05-14 16:29:55 -07001126 }
1127
Michael Jurkadde558b2011-11-09 22:09:06 -08001128 @Override
1129 protected void dispatchDraw(Canvas canvas) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001130 int halfScreenSize = getViewportWidth() / 2;
Michael Jurka8b805b12012-04-18 14:23:14 -07001131 // mOverScrollX is equal to getScrollX() when we're within the normal scroll range.
1132 // Otherwise it is equal to the scaled overscroll position.
Adam Cohenebea84d2011-11-09 17:20:41 -08001133 int screenCenter = mOverScrollX + halfScreenSize;
Michael Jurkadde558b2011-11-09 22:09:06 -08001134
1135 if (screenCenter != mLastScreenCenter || mForceScreenScrolled) {
Michael Jurkab06d95f2012-04-02 06:26:53 -07001136 // set mForceScreenScrolled before calling screenScrolled so that screenScrolled can
1137 // set it for the next frame
1138 mForceScreenScrolled = false;
Michael Jurkadde558b2011-11-09 22:09:06 -08001139 screenScrolled(screenCenter);
1140 mLastScreenCenter = screenCenter;
Michael Jurkadde558b2011-11-09 22:09:06 -08001141 }
1142
1143 // Find out which screens are visible; as an optimization we only call draw on them
1144 final int pageCount = getChildCount();
1145 if (pageCount > 0) {
1146 getVisiblePages(mTempVisiblePagesRange);
1147 final int leftScreen = mTempVisiblePagesRange[0];
1148 final int rightScreen = mTempVisiblePagesRange[1];
Winson Chungc6f10b92011-11-14 11:39:07 -08001149 if (leftScreen != -1 && rightScreen != -1) {
1150 final long drawingTime = getDrawingTime();
1151 // Clip to the bounds
1152 canvas.save();
Michael Jurka8b805b12012-04-18 14:23:14 -07001153 canvas.clipRect(getScrollX(), getScrollY(), getScrollX() + getRight() - getLeft(),
1154 getScrollY() + getBottom() - getTop());
Michael Jurka0142d492010-08-25 17:46:15 -07001155
Adam Cohen7d30a372013-07-01 17:03:59 -07001156 // Draw all the children, leaving the drag view for last
1157 for (int i = pageCount - 1; i >= 0; i--) {
Michael Jurka80c69852011-12-16 14:16:32 -08001158 final View v = getPageAt(i);
Adam Cohen7d30a372013-07-01 17:03:59 -07001159 if (v == mDragView) continue;
Michael Jurka5e368ff2012-05-14 23:13:15 -07001160 if (mForceDrawAllChildrenNextFrame ||
1161 (leftScreen <= i && i <= rightScreen && shouldDrawChild(v))) {
Michael Jurka80c69852011-12-16 14:16:32 -08001162 drawChild(canvas, v, drawingTime);
Michael Jurka80c69852011-12-16 14:16:32 -08001163 }
Winson Chungc6f10b92011-11-14 11:39:07 -08001164 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001165 // Draw the drag view on top (if there is one)
1166 if (mDragView != null) {
1167 drawChild(canvas, mDragView, drawingTime);
1168 }
1169
Michael Jurka5e368ff2012-05-14 23:13:15 -07001170 mForceDrawAllChildrenNextFrame = false;
Winson Chungc6f10b92011-11-14 11:39:07 -08001171 canvas.restore();
Michael Jurkac4fb9172010-09-02 17:19:20 -07001172 }
Michael Jurka0142d492010-08-25 17:46:15 -07001173 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001174 }
1175
1176 @Override
1177 public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
Adam Cohenae4f1552011-10-20 00:15:42 -07001178 int page = indexToPage(indexOfChild(child));
Winson Chung86f77532010-08-24 11:08:22 -07001179 if (page != mCurrentPage || !mScroller.isFinished()) {
1180 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -07001181 return true;
1182 }
1183 return false;
1184 }
1185
1186 @Override
1187 protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
Winson Chung86f77532010-08-24 11:08:22 -07001188 int focusablePage;
1189 if (mNextPage != INVALID_PAGE) {
1190 focusablePage = mNextPage;
Winson Chung321e9ee2010-08-09 13:37:56 -07001191 } else {
Winson Chung86f77532010-08-24 11:08:22 -07001192 focusablePage = mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -07001193 }
Winson Chung86f77532010-08-24 11:08:22 -07001194 View v = getPageAt(focusablePage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001195 if (v != null) {
Adam Cohen76fc0852011-06-17 13:26:23 -07001196 return v.requestFocus(direction, previouslyFocusedRect);
Winson Chung321e9ee2010-08-09 13:37:56 -07001197 }
1198 return false;
1199 }
1200
1201 @Override
1202 public boolean dispatchUnhandledMove(View focused, int direction) {
Adam Cohen0ffac432013-07-10 11:19:26 -07001203 // XXX-RTL: This will be fixed in a future CL
Winson Chung321e9ee2010-08-09 13:37:56 -07001204 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -07001205 if (getCurrentPage() > 0) {
1206 snapToPage(getCurrentPage() - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001207 return true;
1208 }
1209 } else if (direction == View.FOCUS_RIGHT) {
Winson Chung86f77532010-08-24 11:08:22 -07001210 if (getCurrentPage() < getPageCount() - 1) {
1211 snapToPage(getCurrentPage() + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07001212 return true;
1213 }
1214 }
1215 return super.dispatchUnhandledMove(focused, direction);
1216 }
1217
1218 @Override
1219 public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
Adam Cohen0ffac432013-07-10 11:19:26 -07001220 // XXX-RTL: This will be fixed in a future CL
Winson Chung86f77532010-08-24 11:08:22 -07001221 if (mCurrentPage >= 0 && mCurrentPage < getPageCount()) {
alanvaf519952012-05-07 17:33:22 -07001222 getPageAt(mCurrentPage).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -07001223 }
1224 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -07001225 if (mCurrentPage > 0) {
alanvaf519952012-05-07 17:33:22 -07001226 getPageAt(mCurrentPage - 1).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -07001227 }
1228 } else if (direction == View.FOCUS_RIGHT){
Winson Chung86f77532010-08-24 11:08:22 -07001229 if (mCurrentPage < getPageCount() - 1) {
alanvaf519952012-05-07 17:33:22 -07001230 getPageAt(mCurrentPage + 1).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -07001231 }
1232 }
1233 }
1234
1235 /**
1236 * If one of our descendant views decides that it could be focused now, only
Winson Chung86f77532010-08-24 11:08:22 -07001237 * pass that along if it's on the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -07001238 *
Winson Chung86f77532010-08-24 11:08:22 -07001239 * This happens when live folders requery, and if they're off page, they
1240 * end up calling requestFocus, which pulls it on page.
Winson Chung321e9ee2010-08-09 13:37:56 -07001241 */
1242 @Override
1243 public void focusableViewAvailable(View focused) {
Winson Chung86f77532010-08-24 11:08:22 -07001244 View current = getPageAt(mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001245 View v = focused;
1246 while (true) {
1247 if (v == current) {
1248 super.focusableViewAvailable(focused);
1249 return;
1250 }
1251 if (v == this) {
1252 return;
1253 }
1254 ViewParent parent = v.getParent();
1255 if (parent instanceof View) {
1256 v = (View)v.getParent();
1257 } else {
1258 return;
1259 }
1260 }
1261 }
1262
1263 /**
1264 * {@inheritDoc}
1265 */
1266 @Override
1267 public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
1268 if (disallowIntercept) {
1269 // We need to make sure to cancel our long press if
1270 // a scrollable widget takes over touch events
Adam Cohen22f823d2011-09-01 17:22:18 -07001271 final View currentPage = getPageAt(mCurrentPage);
Winson Chung86f77532010-08-24 11:08:22 -07001272 currentPage.cancelLongPress();
Winson Chung321e9ee2010-08-09 13:37:56 -07001273 }
1274 super.requestDisallowInterceptTouchEvent(disallowIntercept);
1275 }
1276
Patrick Dubroyd0ce1ec2011-01-19 18:47:27 -08001277 /**
1278 * Return true if a tap at (x, y) should trigger a flip to the previous page.
1279 */
1280 protected boolean hitsPreviousPage(float x, float y) {
Adam Cohenedb40762013-07-18 16:45:45 -07001281 int offset = (getViewportWidth() - getChildWidth(mCurrentPage)) / 2;
Adam Cohen0ffac432013-07-10 11:19:26 -07001282 if (isLayoutRtl()) {
1283 return (x > (getViewportOffsetX() + getViewportWidth() -
Adam Cohen0cd0eba2013-10-28 14:22:25 -07001284 offset));
Adam Cohen0ffac432013-07-10 11:19:26 -07001285 }
Adam Cohen0cd0eba2013-10-28 14:22:25 -07001286 return (x < getViewportOffsetX() + offset);
Patrick Dubroyd0ce1ec2011-01-19 18:47:27 -08001287 }
1288
1289 /**
1290 * Return true if a tap at (x, y) should trigger a flip to the next page.
1291 */
1292 protected boolean hitsNextPage(float x, float y) {
Adam Cohenedb40762013-07-18 16:45:45 -07001293 int offset = (getViewportWidth() - getChildWidth(mCurrentPage)) / 2;
Adam Cohen0ffac432013-07-10 11:19:26 -07001294 if (isLayoutRtl()) {
Adam Cohen0cd0eba2013-10-28 14:22:25 -07001295 return (x < getViewportOffsetX() + offset);
Adam Cohen0ffac432013-07-10 11:19:26 -07001296 }
1297 return (x > (getViewportOffsetX() + getViewportWidth() -
Adam Cohen0cd0eba2013-10-28 14:22:25 -07001298 offset));
Adam Cohen7d30a372013-07-01 17:03:59 -07001299 }
Winson Chung52aee602013-01-30 12:01:02 -08001300
Adam Cohen7d30a372013-07-01 17:03:59 -07001301 /** Returns whether x and y originated within the buffered viewport */
1302 private boolean isTouchPointInViewportWithBuffer(int x, int y) {
1303 mTmpRect.set(mViewport.left - mViewport.width() / 2, mViewport.top,
1304 mViewport.right + mViewport.width() / 2, mViewport.bottom);
1305 return mTmpRect.contains(x, y);
1306 }
1307
Winson Chung321e9ee2010-08-09 13:37:56 -07001308 @Override
1309 public boolean onInterceptTouchEvent(MotionEvent ev) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001310 if (DISABLE_TOUCH_INTERACTION) {
1311 return false;
1312 }
1313
Winson Chung321e9ee2010-08-09 13:37:56 -07001314 /*
1315 * This method JUST determines whether we want to intercept the motion.
1316 * If we return true, onTouchEvent will be called and we do the actual
1317 * scrolling there.
1318 */
Adam Cohen6342bba2011-03-10 11:33:35 -08001319 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -07001320
Winson Chung45e1d6e2010-11-09 17:19:49 -08001321 // Skip touch handling if there are no pages to swipe
1322 if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev);
1323
Winson Chung321e9ee2010-08-09 13:37:56 -07001324 /*
1325 * Shortcut the most recurring case: the user is in the dragging
1326 * state and he is moving his finger. We want to intercept this
1327 * motion.
1328 */
1329 final int action = ev.getAction();
1330 if ((action == MotionEvent.ACTION_MOVE) &&
1331 (mTouchState == TOUCH_STATE_SCROLLING)) {
1332 return true;
1333 }
1334
Winson Chung321e9ee2010-08-09 13:37:56 -07001335 switch (action & MotionEvent.ACTION_MASK) {
1336 case MotionEvent.ACTION_MOVE: {
1337 /*
1338 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
1339 * whether the user has moved far enough from his original down touch.
1340 */
Michael Jurka1ff706b2010-09-14 17:35:20 -07001341 if (mActivePointerId != INVALID_POINTER) {
1342 determineScrollingStart(ev);
Michael Jurka1ff706b2010-09-14 17:35:20 -07001343 }
1344 // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN
1345 // event. in that case, treat the first occurence of a move event as a ACTION_DOWN
1346 // i.e. fall through to the next case (don't break)
1347 // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events
1348 // while it's small- this was causing a crash before we checked for INVALID_POINTER)
Adam Cohen93c97562013-09-26 13:48:01 -07001349 break;
Winson Chung321e9ee2010-08-09 13:37:56 -07001350 }
1351
1352 case MotionEvent.ACTION_DOWN: {
1353 final float x = ev.getX();
1354 final float y = ev.getY();
1355 // Remember location of down touch
1356 mDownMotionX = x;
Adam Cohen7d30a372013-07-01 17:03:59 -07001357 mDownMotionY = y;
1358 mDownScrollX = getScrollX();
Winson Chung321e9ee2010-08-09 13:37:56 -07001359 mLastMotionX = x;
1360 mLastMotionY = y;
Adam Cohen7d30a372013-07-01 17:03:59 -07001361 float[] p = mapPointFromViewToParent(this, x, y);
1362 mParentDownMotionX = p[0];
1363 mParentDownMotionY = p[1];
Winson Chungc0844aa2011-02-02 15:25:58 -08001364 mLastMotionXRemainder = 0;
Adam Cohenaefd4e12011-02-14 16:39:38 -08001365 mTotalMotionX = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001366 mActivePointerId = ev.getPointerId(0);
Adam Cohen7d30a372013-07-01 17:03:59 -07001367
Winson Chung321e9ee2010-08-09 13:37:56 -07001368 /*
1369 * If being flinged and user touches the screen, initiate drag;
1370 * otherwise don't. mScroller.isFinished should be false when
1371 * being flinged.
1372 */
Michael Jurkafd177c12010-10-19 15:50:43 -07001373 final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX());
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001374 final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop);
1375 if (finishedScrolling) {
1376 mTouchState = TOUCH_STATE_REST;
Adam Cohen8bdbaab2013-10-29 15:25:02 -07001377 abortScrollerAnimation(false);
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001378 } else {
Adam Cohen7d30a372013-07-01 17:03:59 -07001379 if (isTouchPointInViewportWithBuffer((int) mDownMotionX, (int) mDownMotionY)) {
1380 mTouchState = TOUCH_STATE_SCROLLING;
1381 } else {
1382 mTouchState = TOUCH_STATE_REST;
1383 }
Winson Chung5f2aa4e2010-08-20 14:49:25 -07001384 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001385
Winson Chung86f77532010-08-24 11:08:22 -07001386 // check if this can be the beginning of a tap on the side of the pages
Winson Chung321e9ee2010-08-09 13:37:56 -07001387 // to scroll the current page
Adam Cohen7d30a372013-07-01 17:03:59 -07001388 if (!DISABLE_TOUCH_SIDE_PAGES) {
1389 if (mTouchState != TOUCH_STATE_PREV_PAGE && mTouchState != TOUCH_STATE_NEXT_PAGE) {
1390 if (getChildCount() > 0) {
1391 if (hitsPreviousPage(x, y)) {
1392 mTouchState = TOUCH_STATE_PREV_PAGE;
1393 } else if (hitsNextPage(x, y)) {
1394 mTouchState = TOUCH_STATE_NEXT_PAGE;
1395 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001396 }
1397 }
1398 }
1399 break;
1400 }
1401
Winson Chung321e9ee2010-08-09 13:37:56 -07001402 case MotionEvent.ACTION_UP:
Jeff Brown1d0867c2010-12-02 18:27:39 -08001403 case MotionEvent.ACTION_CANCEL:
Adam Cohen7d30a372013-07-01 17:03:59 -07001404 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001405 break;
1406
1407 case MotionEvent.ACTION_POINTER_UP:
1408 onSecondaryPointerUp(ev);
Adam Cohen6342bba2011-03-10 11:33:35 -08001409 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001410 break;
1411 }
1412
1413 /*
1414 * The only time we want to intercept motion events is if we are in the
1415 * drag mode.
1416 */
1417 return mTouchState != TOUCH_STATE_REST;
1418 }
1419
Adam Cohenf8d28232011-02-01 21:47:00 -08001420 protected void determineScrollingStart(MotionEvent ev) {
1421 determineScrollingStart(ev, 1.0f);
1422 }
1423
Winson Chung321e9ee2010-08-09 13:37:56 -07001424 /*
1425 * Determines if we should change the touch state to start scrolling after the
1426 * user moves their touch point too far.
1427 */
Adam Cohenf8d28232011-02-01 21:47:00 -08001428 protected void determineScrollingStart(MotionEvent ev, float touchSlopScale) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001429 // Disallow scrolling if we don't have a valid pointer index
Winson Chung321e9ee2010-08-09 13:37:56 -07001430 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
Adam Cohen7d30a372013-07-01 17:03:59 -07001431 if (pointerIndex == -1) return;
1432
1433 // Disallow scrolling if we started the gesture from outside the viewport
Winson Chung321e9ee2010-08-09 13:37:56 -07001434 final float x = ev.getX(pointerIndex);
1435 final float y = ev.getY(pointerIndex);
Adam Cohen7d30a372013-07-01 17:03:59 -07001436 if (!isTouchPointInViewportWithBuffer((int) x, (int) y)) return;
1437
Winson Chung321e9ee2010-08-09 13:37:56 -07001438 final int xDiff = (int) Math.abs(x - mLastMotionX);
1439 final int yDiff = (int) Math.abs(y - mLastMotionY);
1440
Adam Cohenf8d28232011-02-01 21:47:00 -08001441 final int touchSlop = Math.round(touchSlopScale * mTouchSlop);
Winson Chung321e9ee2010-08-09 13:37:56 -07001442 boolean xPaged = xDiff > mPagingTouchSlop;
1443 boolean xMoved = xDiff > touchSlop;
1444 boolean yMoved = yDiff > touchSlop;
1445
Adam Cohenf8d28232011-02-01 21:47:00 -08001446 if (xMoved || xPaged || yMoved) {
Michael Jurka0142d492010-08-25 17:46:15 -07001447 if (mUsePagingTouchSlop ? xPaged : xMoved) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001448 // Scroll if the user moved far enough along the X axis
1449 mTouchState = TOUCH_STATE_SCROLLING;
Adam Cohen6342bba2011-03-10 11:33:35 -08001450 mTotalMotionX += Math.abs(mLastMotionX - x);
Winson Chung321e9ee2010-08-09 13:37:56 -07001451 mLastMotionX = x;
Winson Chungc0844aa2011-02-02 15:25:58 -08001452 mLastMotionXRemainder = 0;
Adam Cohen7d30a372013-07-01 17:03:59 -07001453 mTouchX = getViewportOffsetX() + getScrollX();
Michael Jurka0142d492010-08-25 17:46:15 -07001454 mSmoothingTime = System.nanoTime() / NANOTIME_DIV;
1455 pageBeginMoving();
Winson Chung321e9ee2010-08-09 13:37:56 -07001456 }
Adam Cohenf8d28232011-02-01 21:47:00 -08001457 }
1458 }
1459
Adam Cohen7d30a372013-07-01 17:03:59 -07001460 protected float getMaxScrollProgress() {
1461 return 1.0f;
1462 }
1463
Adam Cohenf8d28232011-02-01 21:47:00 -08001464 protected void cancelCurrentPageLongPress() {
1465 if (mAllowLongPress) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001466 //mAllowLongPress = false;
Adam Cohenf8d28232011-02-01 21:47:00 -08001467 // Try canceling the long press. It could also have been scheduled
1468 // by a distant descendant, so use the mAllowLongPress flag to block
1469 // everything
1470 final View currentPage = getPageAt(mCurrentPage);
1471 if (currentPage != null) {
1472 currentPage.cancelLongPress();
Winson Chung321e9ee2010-08-09 13:37:56 -07001473 }
1474 }
1475 }
1476
Adam Cohen7d30a372013-07-01 17:03:59 -07001477 protected float getBoundedScrollProgress(int screenCenter, View v, int page) {
1478 final int halfScreenSize = getViewportWidth() / 2;
1479
1480 screenCenter = Math.min(getScrollX() + halfScreenSize, screenCenter);
1481 screenCenter = Math.max(halfScreenSize, screenCenter);
1482
1483 return getScrollProgress(screenCenter, v, page);
1484 }
1485
Adam Cohenb5ba0972011-09-07 18:02:31 -07001486 protected float getScrollProgress(int screenCenter, View v, int page) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001487 final int halfScreenSize = getViewportWidth() / 2;
Adam Cohenb5ba0972011-09-07 18:02:31 -07001488
Adam Cohen0cd0eba2013-10-28 14:22:25 -07001489 int offset = (getViewportWidth() - getChildWidth(page)) / 2;
1490 int totalDistance = v.getMeasuredWidth() + offset;
Adam Cohenedb40762013-07-18 16:45:45 -07001491 int delta = screenCenter - (getScrollForPage(page) + halfScreenSize);
Adam Cohenb5ba0972011-09-07 18:02:31 -07001492
1493 float scrollProgress = delta / (totalDistance * 1.0f);
Adam Cohen7d30a372013-07-01 17:03:59 -07001494 scrollProgress = Math.min(scrollProgress, getMaxScrollProgress());
1495 scrollProgress = Math.max(scrollProgress, - getMaxScrollProgress());
Adam Cohenb5ba0972011-09-07 18:02:31 -07001496 return scrollProgress;
1497 }
1498
Adam Cohenedb40762013-07-18 16:45:45 -07001499 public int getScrollForPage(int index) {
Adam Cohen1f1f45d2013-10-02 09:40:18 -07001500 if (mPageScrolls == null || index >= mPageScrolls.length || index < 0) {
Adam Cohenedb40762013-07-18 16:45:45 -07001501 return 0;
1502 } else {
1503 return mPageScrolls[index];
1504 }
1505 }
1506
Adam Cohen564a2e72013-10-09 14:47:32 -07001507 // While layout transitions are occurring, a child's position may stray from its baseline
1508 // position. This method returns the magnitude of this stray at any given time.
1509 public int getLayoutTransitionOffsetForPage(int index) {
1510 if (mPageScrolls == null || index >= mPageScrolls.length || index < 0) {
1511 return 0;
1512 } else {
1513 View child = getChildAt(index);
1514 int scrollOffset = (getViewportWidth() - child.getMeasuredWidth()) / 2;
1515 int baselineX = mPageScrolls[index] + scrollOffset + getViewportOffsetX();
1516 return (int) (child.getX() - baselineX);
1517 }
1518 }
1519
Adam Cohene0f66b52010-11-23 15:06:07 -08001520 // This curve determines how the effect of scrolling over the limits of the page dimishes
1521 // as the user pulls further and further from the bounds
1522 private float overScrollInfluenceCurve(float f) {
1523 f -= 1.0f;
1524 return f * f * f + 1.0f;
1525 }
1526
Adam Cohenb5ba0972011-09-07 18:02:31 -07001527 protected void acceleratedOverScroll(float amount) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001528 int screenSize = getViewportWidth();
Adam Cohenb5ba0972011-09-07 18:02:31 -07001529
1530 // We want to reach the max over scroll effect when the user has
1531 // over scrolled half the size of the screen
1532 float f = OVERSCROLL_ACCELERATE_FACTOR * (amount / screenSize);
1533
1534 if (f == 0) return;
1535
1536 // Clamp this factor, f, to -1 < f < 1
1537 if (Math.abs(f) >= 1) {
1538 f /= Math.abs(f);
1539 }
1540
1541 int overScrollAmount = (int) Math.round(f * screenSize);
1542 if (amount < 0) {
Adam Cohenebea84d2011-11-09 17:20:41 -08001543 mOverScrollX = overScrollAmount;
Michael Jurka8b805b12012-04-18 14:23:14 -07001544 super.scrollTo(0, getScrollY());
Adam Cohenb5ba0972011-09-07 18:02:31 -07001545 } else {
Adam Cohenebea84d2011-11-09 17:20:41 -08001546 mOverScrollX = mMaxScrollX + overScrollAmount;
Michael Jurka8b805b12012-04-18 14:23:14 -07001547 super.scrollTo(mMaxScrollX, getScrollY());
Adam Cohenb5ba0972011-09-07 18:02:31 -07001548 }
1549 invalidate();
1550 }
1551
1552 protected void dampedOverScroll(float amount) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001553 int screenSize = getViewportWidth();
Adam Cohene0f66b52010-11-23 15:06:07 -08001554
1555 float f = (amount / screenSize);
1556
1557 if (f == 0) return;
1558 f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f)));
1559
Adam Cohen7bfc9792011-01-28 13:52:37 -08001560 // Clamp this factor, f, to -1 < f < 1
1561 if (Math.abs(f) >= 1) {
1562 f /= Math.abs(f);
1563 }
1564
Adam Cohene0f66b52010-11-23 15:06:07 -08001565 int overScrollAmount = (int) Math.round(OVERSCROLL_DAMP_FACTOR * f * screenSize);
Adam Cohen68d73932010-11-15 10:50:58 -08001566 if (amount < 0) {
Adam Cohenebea84d2011-11-09 17:20:41 -08001567 mOverScrollX = overScrollAmount;
Michael Jurka8b805b12012-04-18 14:23:14 -07001568 super.scrollTo(0, getScrollY());
Adam Cohen68d73932010-11-15 10:50:58 -08001569 } else {
Adam Cohenebea84d2011-11-09 17:20:41 -08001570 mOverScrollX = mMaxScrollX + overScrollAmount;
Michael Jurka8b805b12012-04-18 14:23:14 -07001571 super.scrollTo(mMaxScrollX, getScrollY());
Adam Cohen68d73932010-11-15 10:50:58 -08001572 }
1573 invalidate();
1574 }
1575
Adam Cohenb5ba0972011-09-07 18:02:31 -07001576 protected void overScroll(float amount) {
1577 dampedOverScroll(amount);
1578 }
1579
Michael Jurkac5b262c2011-01-12 20:24:50 -08001580 protected float maxOverScroll() {
1581 // Using the formula in overScroll, assuming that f = 1.0 (which it should generally not
Adam Cohenb5ba0972011-09-07 18:02:31 -07001582 // exceed). Used to find out how much extra wallpaper we need for the over scroll effect
Michael Jurkac5b262c2011-01-12 20:24:50 -08001583 float f = 1.0f;
1584 f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f)));
1585 return OVERSCROLL_DAMP_FACTOR * f;
1586 }
1587
Adam Cohenf358a4b2013-07-23 16:47:31 -07001588 protected void enableFreeScroll() {
1589 setEnableFreeScroll(true, -1);
1590 }
1591
1592 protected void disableFreeScroll(int snapPage) {
1593 setEnableFreeScroll(false, snapPage);
1594 }
1595
Adam Cohen7a9e58a2013-10-01 18:02:13 -07001596 void updateFreescrollBounds() {
1597 getOverviewModePages(mTempVisiblePagesRange);
1598 if (isLayoutRtl()) {
1599 mFreeScrollMinScrollX = getScrollForPage(mTempVisiblePagesRange[1]);
1600 mFreeScrollMaxScrollX = getScrollForPage(mTempVisiblePagesRange[0]);
1601 } else {
1602 mFreeScrollMinScrollX = getScrollForPage(mTempVisiblePagesRange[0]);
1603 mFreeScrollMaxScrollX = getScrollForPage(mTempVisiblePagesRange[1]);
1604 }
1605 }
1606
Adam Cohenf358a4b2013-07-23 16:47:31 -07001607 private void setEnableFreeScroll(boolean freeScroll, int snapPage) {
1608 mFreeScroll = freeScroll;
1609
1610 if (snapPage == -1) {
1611 snapPage = getPageNearestToCenterOfScreen();
1612 }
1613
Adam Cohenf358a4b2013-07-23 16:47:31 -07001614 if (!mFreeScroll) {
1615 snapToPage(snapPage);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001616 } else {
Adam Cohen7a9e58a2013-10-01 18:02:13 -07001617 updateFreescrollBounds();
1618 getOverviewModePages(mTempVisiblePagesRange);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001619 if (getCurrentPage() < mTempVisiblePagesRange[0]) {
1620 setCurrentPage(mTempVisiblePagesRange[0]);
1621 } else if (getCurrentPage() > mTempVisiblePagesRange[1]) {
1622 setCurrentPage(mTempVisiblePagesRange[1]);
1623 }
1624 }
1625
1626 setEnableOverscroll(!freeScroll);
1627 }
1628
1629 private void setEnableOverscroll(boolean enable) {
1630 mAllowOverScroll = enable;
1631 }
1632
1633 int getNearestHoverOverPageIndex() {
1634 if (mDragView != null) {
1635 int dragX = (int) (mDragView.getLeft() + (mDragView.getMeasuredWidth() / 2)
1636 + mDragView.getTranslationX());
1637 getOverviewModePages(mTempVisiblePagesRange);
1638 int minDistance = Integer.MAX_VALUE;
1639 int minIndex = indexOfChild(mDragView);
1640 for (int i = mTempVisiblePagesRange[0]; i <= mTempVisiblePagesRange[1]; i++) {
1641 View page = getPageAt(i);
1642 int pageX = (int) (page.getLeft() + page.getMeasuredWidth() / 2);
1643 int d = Math.abs(dragX - pageX);
1644 if (d < minDistance) {
1645 minIndex = i;
1646 minDistance = d;
1647 }
1648 }
1649 return minIndex;
1650 }
1651 return -1;
1652 }
1653
Winson Chung321e9ee2010-08-09 13:37:56 -07001654 @Override
1655 public boolean onTouchEvent(MotionEvent ev) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001656 if (DISABLE_TOUCH_INTERACTION) {
1657 return false;
1658 }
1659
Adam Cohen1697b792013-09-17 19:08:21 -07001660 super.onTouchEvent(ev);
1661
Winson Chung45e1d6e2010-11-09 17:19:49 -08001662 // Skip touch handling if there are no pages to swipe
1663 if (getChildCount() <= 0) return super.onTouchEvent(ev);
1664
Michael Jurkab8f06722010-10-10 15:58:46 -07001665 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -07001666
1667 final int action = ev.getAction();
1668
1669 switch (action & MotionEvent.ACTION_MASK) {
1670 case MotionEvent.ACTION_DOWN:
1671 /*
1672 * If being flinged and user touches, stop the fling. isFinished
1673 * will be false if being flinged.
1674 */
1675 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -07001676 abortScrollerAnimation(false);
Winson Chung321e9ee2010-08-09 13:37:56 -07001677 }
1678
1679 // Remember where the motion event started
1680 mDownMotionX = mLastMotionX = ev.getX();
Adam Cohen7d30a372013-07-01 17:03:59 -07001681 mDownMotionY = mLastMotionY = ev.getY();
1682 mDownScrollX = getScrollX();
1683 float[] p = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY);
1684 mParentDownMotionX = p[0];
1685 mParentDownMotionY = p[1];
Winson Chungc0844aa2011-02-02 15:25:58 -08001686 mLastMotionXRemainder = 0;
Adam Cohenaefd4e12011-02-14 16:39:38 -08001687 mTotalMotionX = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001688 mActivePointerId = ev.getPointerId(0);
Adam Cohen7d30a372013-07-01 17:03:59 -07001689
Michael Jurka0142d492010-08-25 17:46:15 -07001690 if (mTouchState == TOUCH_STATE_SCROLLING) {
1691 pageBeginMoving();
1692 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001693 break;
1694
1695 case MotionEvent.ACTION_MOVE:
1696 if (mTouchState == TOUCH_STATE_SCROLLING) {
1697 // Scroll to follow the motion event
1698 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
Adam Cohen7d30a372013-07-01 17:03:59 -07001699
1700 if (pointerIndex == -1) return true;
1701
Winson Chung321e9ee2010-08-09 13:37:56 -07001702 final float x = ev.getX(pointerIndex);
Winson Chungc0844aa2011-02-02 15:25:58 -08001703 final float deltaX = mLastMotionX + mLastMotionXRemainder - x;
Winson Chung321e9ee2010-08-09 13:37:56 -07001704
Adam Cohenaefd4e12011-02-14 16:39:38 -08001705 mTotalMotionX += Math.abs(deltaX);
1706
Winson Chungc0844aa2011-02-02 15:25:58 -08001707 // Only scroll and update mLastMotionX if we have moved some discrete amount. We
1708 // keep the remainder because we are actually testing if we've moved from the last
1709 // scrolled position (which is discrete).
1710 if (Math.abs(deltaX) >= 1.0f) {
Adam Cohen68d73932010-11-15 10:50:58 -08001711 mTouchX += deltaX;
1712 mSmoothingTime = System.nanoTime() / NANOTIME_DIV;
1713 if (!mDeferScrollUpdate) {
Winson Chungc0844aa2011-02-02 15:25:58 -08001714 scrollBy((int) deltaX, 0);
Winson Chung785d2eb2011-04-14 16:08:02 -07001715 if (DEBUG) Log.d(TAG, "onTouchEvent().Scrolling: " + deltaX);
Adam Cohen68d73932010-11-15 10:50:58 -08001716 } else {
1717 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -07001718 }
Winson Chungc0844aa2011-02-02 15:25:58 -08001719 mLastMotionX = x;
1720 mLastMotionXRemainder = deltaX - (int) deltaX;
Winson Chung321e9ee2010-08-09 13:37:56 -07001721 } else {
1722 awakenScrollBars();
1723 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001724 } else if (mTouchState == TOUCH_STATE_REORDERING) {
1725 // Update the last motion position
1726 mLastMotionX = ev.getX();
1727 mLastMotionY = ev.getY();
1728
1729 // Update the parent down so that our zoom animations take this new movement into
1730 // account
1731 float[] pt = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY);
1732 mParentDownMotionX = pt[0];
1733 mParentDownMotionY = pt[1];
1734 updateDragViewTranslationDuringDrag();
1735
1736 // Find the closest page to the touch point
1737 final int dragViewIndex = indexOfChild(mDragView);
Adam Cohen7d30a372013-07-01 17:03:59 -07001738
1739 // Change the drag view if we are hovering over the drop target
1740 boolean isHoveringOverDelete = isHoveringOverDeleteDropTarget(
1741 (int) mParentDownMotionX, (int) mParentDownMotionY);
1742 setPageHoveringOverDeleteDropTarget(dragViewIndex, isHoveringOverDelete);
1743
Adam Cohen7d30a372013-07-01 17:03:59 -07001744 if (DEBUG) Log.d(TAG, "mLastMotionX: " + mLastMotionX);
1745 if (DEBUG) Log.d(TAG, "mLastMotionY: " + mLastMotionY);
1746 if (DEBUG) Log.d(TAG, "mParentDownMotionX: " + mParentDownMotionX);
1747 if (DEBUG) Log.d(TAG, "mParentDownMotionY: " + mParentDownMotionY);
1748
Adam Cohenf358a4b2013-07-23 16:47:31 -07001749 final int pageUnderPointIndex = getNearestHoverOverPageIndex();
1750 if (pageUnderPointIndex > -1 && pageUnderPointIndex != indexOfChild(mDragView) &&
1751 !isHoveringOverDelete) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001752 mTempVisiblePagesRange[0] = 0;
1753 mTempVisiblePagesRange[1] = getPageCount() - 1;
Adam Cohenf358a4b2013-07-23 16:47:31 -07001754 getOverviewModePages(mTempVisiblePagesRange);
Adam Cohen7d30a372013-07-01 17:03:59 -07001755 if (mTempVisiblePagesRange[0] <= pageUnderPointIndex &&
1756 pageUnderPointIndex <= mTempVisiblePagesRange[1] &&
1757 pageUnderPointIndex != mSidePageHoverIndex && mScroller.isFinished()) {
1758 mSidePageHoverIndex = pageUnderPointIndex;
1759 mSidePageHoverRunnable = new Runnable() {
1760 @Override
1761 public void run() {
Adam Cohen7d30a372013-07-01 17:03:59 -07001762 // Setup the scroll to the correct page before we swap the views
1763 snapToPage(pageUnderPointIndex);
1764
1765 // For each of the pages between the paged view and the drag view,
1766 // animate them from the previous position to the new position in
1767 // the layout (as a result of the drag view moving in the layout)
1768 int shiftDelta = (dragViewIndex < pageUnderPointIndex) ? -1 : 1;
1769 int lowerIndex = (dragViewIndex < pageUnderPointIndex) ?
1770 dragViewIndex + 1 : pageUnderPointIndex;
1771 int upperIndex = (dragViewIndex > pageUnderPointIndex) ?
1772 dragViewIndex - 1 : pageUnderPointIndex;
1773 for (int i = lowerIndex; i <= upperIndex; ++i) {
1774 View v = getChildAt(i);
1775 // dragViewIndex < pageUnderPointIndex, so after we remove the
1776 // drag view all subsequent views to pageUnderPointIndex will
1777 // shift down.
1778 int oldX = getViewportOffsetX() + getChildOffset(i);
1779 int newX = getViewportOffsetX() + getChildOffset(i + shiftDelta);
1780
1781 // Animate the view translation from its old position to its new
1782 // position
1783 AnimatorSet anim = (AnimatorSet) v.getTag(ANIM_TAG_KEY);
1784 if (anim != null) {
1785 anim.cancel();
1786 }
1787
1788 v.setTranslationX(oldX - newX);
1789 anim = new AnimatorSet();
1790 anim.setDuration(REORDERING_REORDER_REPOSITION_DURATION);
1791 anim.playTogether(
1792 ObjectAnimator.ofFloat(v, "translationX", 0f));
1793 anim.start();
1794 v.setTag(anim);
1795 }
1796
1797 removeView(mDragView);
1798 onRemoveView(mDragView, false);
1799 addView(mDragView, pageUnderPointIndex);
1800 onAddView(mDragView, pageUnderPointIndex);
1801 mSidePageHoverIndex = -1;
Winson Chungd2be3812013-07-16 11:11:32 -07001802 mPageIndicator.setActiveMarker(getNextPage());
Adam Cohen7d30a372013-07-01 17:03:59 -07001803 }
1804 };
1805 postDelayed(mSidePageHoverRunnable, REORDERING_SIDE_PAGE_HOVER_TIMEOUT);
1806 }
1807 } else {
1808 removeCallbacks(mSidePageHoverRunnable);
1809 mSidePageHoverIndex = -1;
1810 }
Adam Cohen564976a2010-10-13 18:52:07 -07001811 } else {
Winson Chung321e9ee2010-08-09 13:37:56 -07001812 determineScrollingStart(ev);
1813 }
1814 break;
1815
1816 case MotionEvent.ACTION_UP:
1817 if (mTouchState == TOUCH_STATE_SCROLLING) {
1818 final int activePointerId = mActivePointerId;
1819 final int pointerIndex = ev.findPointerIndex(activePointerId);
1820 final float x = ev.getX(pointerIndex);
1821 final VelocityTracker velocityTracker = mVelocityTracker;
1822 velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
1823 int velocityX = (int) velocityTracker.getXVelocity(activePointerId);
Winson Chung9cfd25f2010-10-24 16:09:28 -07001824 final int deltaX = (int) (x - mDownMotionX);
Adam Cohen96d30a12013-07-16 18:13:21 -07001825 final int pageWidth = getPageAt(mCurrentPage).getMeasuredWidth();
Adam Cohen00481b32011-11-18 12:03:48 -08001826 boolean isSignificantMove = Math.abs(deltaX) > pageWidth *
1827 SIGNIFICANT_MOVE_THRESHOLD;
Adam Cohenaefd4e12011-02-14 16:39:38 -08001828
Adam Cohenb64cb5a2011-02-15 13:53:42 -08001829 mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x);
1830
Adam Cohen00481b32011-11-18 12:03:48 -08001831 boolean isFling = mTotalMotionX > MIN_LENGTH_FOR_FLING &&
Adam Cohen265b9a62011-12-07 14:37:18 -08001832 Math.abs(velocityX) > mFlingThresholdVelocity;
Adam Cohen00481b32011-11-18 12:03:48 -08001833
Adam Cohenf358a4b2013-07-23 16:47:31 -07001834 if (!mFreeScroll) {
1835 // In the case that the page is moved far to one direction and then is flung
1836 // in the opposite direction, we use a threshold to determine whether we should
1837 // just return to the starting page, or if we should skip one further.
1838 boolean returnToOriginalPage = false;
1839 if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD &&
1840 Math.signum(velocityX) != Math.signum(deltaX) && isFling) {
1841 returnToOriginalPage = true;
1842 }
Adam Cohenaefd4e12011-02-14 16:39:38 -08001843
Adam Cohenf358a4b2013-07-23 16:47:31 -07001844 int finalPage;
1845 // We give flings precedence over large moves, which is why we short-circuit our
1846 // test for a large move if a fling has been registered. That is, a large
1847 // move to the left and fling to the right will register as a fling to the right.
1848 final boolean isRtl = isLayoutRtl();
1849 boolean isDeltaXLeft = isRtl ? deltaX > 0 : deltaX < 0;
1850 boolean isVelocityXLeft = isRtl ? velocityX > 0 : velocityX < 0;
1851 if (((isSignificantMove && !isDeltaXLeft && !isFling) ||
1852 (isFling && !isVelocityXLeft)) && mCurrentPage > 0) {
1853 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage - 1;
1854 snapToPageWithVelocity(finalPage, velocityX);
1855 } else if (((isSignificantMove && isDeltaXLeft && !isFling) ||
1856 (isFling && isVelocityXLeft)) &&
1857 mCurrentPage < getChildCount() - 1) {
1858 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage + 1;
1859 snapToPageWithVelocity(finalPage, velocityX);
1860 } else {
1861 snapToDestination();
1862 } } else if (mTouchState == TOUCH_STATE_PREV_PAGE) {
1863 // at this point we have not moved beyond the touch slop
1864 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
1865 // we can just page
1866 int nextPage = Math.max(0, mCurrentPage - 1);
1867 if (nextPage != mCurrentPage) {
1868 snapToPage(nextPage);
1869 } else {
1870 snapToDestination();
1871 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001872 } else {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001873 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -07001874 abortScrollerAnimation(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001875 }
1876
1877 float scaleX = getScaleX();
1878 int vX = (int) (-velocityX * scaleX);
1879 int initialScrollX = (int) (getScrollX() * scaleX);
1880
1881 mScroller.fling(initialScrollX,
1882 getScrollY(), vX, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, 0, 0);
1883 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -07001884 }
Patrick Dubroyd0ce1ec2011-01-19 18:47:27 -08001885 } else if (mTouchState == TOUCH_STATE_NEXT_PAGE) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001886 // at this point we have not moved beyond the touch slop
1887 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so
1888 // we can just page
Winson Chung86f77532010-08-24 11:08:22 -07001889 int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1);
1890 if (nextPage != mCurrentPage) {
1891 snapToPage(nextPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001892 } else {
1893 snapToDestination();
1894 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001895 } else if (mTouchState == TOUCH_STATE_REORDERING) {
1896 // Update the last motion position
1897 mLastMotionX = ev.getX();
1898 mLastMotionY = ev.getY();
1899
1900 // Update the parent down so that our zoom animations take this new movement into
1901 // account
1902 float[] pt = mapPointFromViewToParent(this, mLastMotionX, mLastMotionY);
1903 mParentDownMotionX = pt[0];
1904 mParentDownMotionY = pt[1];
1905 updateDragViewTranslationDuringDrag();
1906 boolean handledFling = false;
1907 if (!DISABLE_FLING_TO_DELETE) {
1908 // Check the velocity and see if we are flinging-to-delete
1909 PointF flingToDeleteVector = isFlingingToDelete();
1910 if (flingToDeleteVector != null) {
1911 onFlingToDelete(flingToDeleteVector);
1912 handledFling = true;
1913 }
1914 }
1915 if (!handledFling && isHoveringOverDeleteDropTarget((int) mParentDownMotionX,
1916 (int) mParentDownMotionY)) {
1917 onDropToDelete();
1918 }
Jeff Brown1d0867c2010-12-02 18:27:39 -08001919 } else {
Adam Cohendbdff6b2013-09-18 19:09:15 -07001920 if (!mCancelTap) {
1921 onUnhandledTap(ev);
1922 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001923 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001924
1925 // Remove the callback to wait for the side page hover timeout
1926 removeCallbacks(mSidePageHoverRunnable);
1927 // End any intermediate reordering states
1928 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001929 break;
1930
1931 case MotionEvent.ACTION_CANCEL:
Michael Jurkab8f06722010-10-10 15:58:46 -07001932 if (mTouchState == TOUCH_STATE_SCROLLING) {
1933 snapToDestination();
1934 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001935 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001936 break;
1937
1938 case MotionEvent.ACTION_POINTER_UP:
1939 onSecondaryPointerUp(ev);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001940 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001941 break;
1942 }
1943
1944 return true;
1945 }
1946
Adam Cohen7d30a372013-07-01 17:03:59 -07001947 public void onFlingToDelete(View v) {}
1948 public void onRemoveView(View v, boolean deletePermanently) {}
1949 public void onRemoveViewAnimationCompleted() {}
1950 public void onAddView(View v, int index) {}
1951
1952 private void resetTouchState() {
1953 releaseVelocityTracker();
1954 endReordering();
Adam Cohendbdff6b2013-09-18 19:09:15 -07001955 mCancelTap = false;
Adam Cohen7d30a372013-07-01 17:03:59 -07001956 mTouchState = TOUCH_STATE_REST;
1957 mActivePointerId = INVALID_POINTER;
Adam Cohen7d30a372013-07-01 17:03:59 -07001958 }
1959
Adam Cohen1697b792013-09-17 19:08:21 -07001960 protected void onUnhandledTap(MotionEvent ev) {
1961 ((Launcher) getContext()).onClick(this);
1962 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001963
Winson Chung185d7162011-02-28 13:47:29 -08001964 @Override
1965 public boolean onGenericMotionEvent(MotionEvent event) {
1966 if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
1967 switch (event.getAction()) {
1968 case MotionEvent.ACTION_SCROLL: {
1969 // Handle mouse (or ext. device) by shifting the page depending on the scroll
1970 final float vscroll;
1971 final float hscroll;
1972 if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) {
1973 vscroll = 0;
1974 hscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
1975 } else {
1976 vscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
1977 hscroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
1978 }
1979 if (hscroll != 0 || vscroll != 0) {
Adam Cohen0ffac432013-07-10 11:19:26 -07001980 boolean isForwardScroll = isLayoutRtl() ? (hscroll < 0 || vscroll < 0)
1981 : (hscroll > 0 || vscroll > 0);
1982 if (isForwardScroll) {
Winson Chung185d7162011-02-28 13:47:29 -08001983 scrollRight();
1984 } else {
1985 scrollLeft();
1986 }
1987 return true;
1988 }
1989 }
1990 }
1991 }
1992 return super.onGenericMotionEvent(event);
1993 }
1994
Michael Jurkab8f06722010-10-10 15:58:46 -07001995 private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) {
1996 if (mVelocityTracker == null) {
1997 mVelocityTracker = VelocityTracker.obtain();
1998 }
1999 mVelocityTracker.addMovement(ev);
2000 }
2001
2002 private void releaseVelocityTracker() {
2003 if (mVelocityTracker != null) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07002004 mVelocityTracker.clear();
Michael Jurkab8f06722010-10-10 15:58:46 -07002005 mVelocityTracker.recycle();
2006 mVelocityTracker = null;
2007 }
2008 }
2009
Winson Chung321e9ee2010-08-09 13:37:56 -07002010 private void onSecondaryPointerUp(MotionEvent ev) {
2011 final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
2012 MotionEvent.ACTION_POINTER_INDEX_SHIFT;
2013 final int pointerId = ev.getPointerId(pointerIndex);
2014 if (pointerId == mActivePointerId) {
2015 // This was our active pointer going up. Choose a new
2016 // active pointer and adjust accordingly.
2017 // TODO: Make this decision more intelligent.
2018 final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
2019 mLastMotionX = mDownMotionX = ev.getX(newPointerIndex);
2020 mLastMotionY = ev.getY(newPointerIndex);
Winson Chungc0844aa2011-02-02 15:25:58 -08002021 mLastMotionXRemainder = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07002022 mActivePointerId = ev.getPointerId(newPointerIndex);
2023 if (mVelocityTracker != null) {
2024 mVelocityTracker.clear();
2025 }
2026 }
Jeff Brown1d0867c2010-12-02 18:27:39 -08002027 }
2028
Winson Chung321e9ee2010-08-09 13:37:56 -07002029 @Override
2030 public void requestChildFocus(View child, View focused) {
2031 super.requestChildFocus(child, focused);
Adam Cohenae4f1552011-10-20 00:15:42 -07002032 int page = indexToPage(indexOfChild(child));
Winson Chung97d85d22011-04-13 11:27:36 -07002033 if (page >= 0 && page != getCurrentPage() && !isInTouchMode()) {
Winson Chung86f77532010-08-24 11:08:22 -07002034 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -07002035 }
2036 }
2037
Winson Chung1908d072011-02-24 18:09:44 -08002038 protected int getChildWidth(int index) {
Adam Cohen96d30a12013-07-16 18:13:21 -07002039 return getPageAt(index).getMeasuredWidth();
Winson Chung1908d072011-02-24 18:09:44 -08002040 }
2041
Adam Cohen7d30a372013-07-01 17:03:59 -07002042 int getPageNearestToPoint(float x) {
2043 int index = 0;
2044 for (int i = 0; i < getChildCount(); ++i) {
2045 if (x < getChildAt(i).getRight() - getScrollX()) {
2046 return index;
2047 } else {
2048 index++;
2049 }
2050 }
2051 return Math.min(index, getChildCount() - 1);
2052 }
2053
Adam Cohend19d3ca2010-09-15 14:43:42 -07002054 int getPageNearestToCenterOfScreen() {
Adam Cohen22f823d2011-09-01 17:22:18 -07002055 int minDistanceFromScreenCenter = Integer.MAX_VALUE;
Winson Chung321e9ee2010-08-09 13:37:56 -07002056 int minDistanceFromScreenCenterIndex = -1;
Adam Cohen7d30a372013-07-01 17:03:59 -07002057 int screenCenter = getViewportOffsetX() + getScrollX() + (getViewportWidth() / 2);
Winson Chung321e9ee2010-08-09 13:37:56 -07002058 final int childCount = getChildCount();
2059 for (int i = 0; i < childCount; ++i) {
Adam Cohen22f823d2011-09-01 17:22:18 -07002060 View layout = (View) getPageAt(i);
Adam Cohen96d30a12013-07-16 18:13:21 -07002061 int childWidth = layout.getMeasuredWidth();
Winson Chung321e9ee2010-08-09 13:37:56 -07002062 int halfChildWidth = (childWidth / 2);
Adam Cohen7d30a372013-07-01 17:03:59 -07002063 int childCenter = getViewportOffsetX() + getChildOffset(i) + halfChildWidth;
Winson Chung321e9ee2010-08-09 13:37:56 -07002064 int distanceFromScreenCenter = Math.abs(childCenter - screenCenter);
2065 if (distanceFromScreenCenter < minDistanceFromScreenCenter) {
2066 minDistanceFromScreenCenter = distanceFromScreenCenter;
2067 minDistanceFromScreenCenterIndex = i;
2068 }
2069 }
Adam Cohend19d3ca2010-09-15 14:43:42 -07002070 return minDistanceFromScreenCenterIndex;
2071 }
2072
2073 protected void snapToDestination() {
2074 snapToPage(getPageNearestToCenterOfScreen(), PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07002075 }
2076
Adam Cohene0f66b52010-11-23 15:06:07 -08002077 private static class ScrollInterpolator implements Interpolator {
2078 public ScrollInterpolator() {
2079 }
2080
2081 public float getInterpolation(float t) {
2082 t -= 1.0f;
2083 return t*t*t*t*t + 1;
2084 }
2085 }
2086
2087 // We want the duration of the page snap animation to be influenced by the distance that
2088 // the screen has to travel, however, we don't want this duration to be effected in a
2089 // purely linear fashion. Instead, we use this method to moderate the effect that the distance
2090 // of travel has on the overall snap duration.
2091 float distanceInfluenceForSnapDuration(float f) {
2092 f -= 0.5f; // center the values about 0.
2093 f *= 0.3f * Math.PI / 2.0f;
2094 return (float) Math.sin(f);
2095 }
2096
Michael Jurka0142d492010-08-25 17:46:15 -07002097 protected void snapToPageWithVelocity(int whichPage, int velocity) {
Adam Cohene0f66b52010-11-23 15:06:07 -08002098 whichPage = Math.max(0, Math.min(whichPage, getChildCount() - 1));
Adam Cohen7d30a372013-07-01 17:03:59 -07002099 int halfScreenSize = getViewportWidth() / 2;
Adam Cohene0f66b52010-11-23 15:06:07 -08002100
Adam Cohenedb40762013-07-18 16:45:45 -07002101 final int newX = getScrollForPage(whichPage);
Adam Cohene0f66b52010-11-23 15:06:07 -08002102 int delta = newX - mUnboundedScrollX;
2103 int duration = 0;
2104
Adam Cohen265b9a62011-12-07 14:37:18 -08002105 if (Math.abs(velocity) < mMinFlingVelocity) {
Adam Cohene0f66b52010-11-23 15:06:07 -08002106 // If the velocity is low enough, then treat this more as an automatic page advance
2107 // as opposed to an apparent physical response to flinging
2108 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
2109 return;
2110 }
2111
2112 // Here we compute a "distance" that will be used in the computation of the overall
2113 // snap duration. This is a function of the actual distance that needs to be traveled;
2114 // we keep this value close to half screen size in order to reduce the variance in snap
2115 // duration as a function of the distance the page needs to travel.
Michael Jurka20b7ca92011-06-07 20:09:16 -07002116 float distanceRatio = Math.min(1f, 1.0f * Math.abs(delta) / (2 * halfScreenSize));
Adam Cohene0f66b52010-11-23 15:06:07 -08002117 float distance = halfScreenSize + halfScreenSize *
2118 distanceInfluenceForSnapDuration(distanceRatio);
2119
2120 velocity = Math.abs(velocity);
Adam Cohen265b9a62011-12-07 14:37:18 -08002121 velocity = Math.max(mMinSnapVelocity, velocity);
Adam Cohene0f66b52010-11-23 15:06:07 -08002122
2123 // we want the page's snap velocity to approximately match the velocity at which the
2124 // user flings, so we scale the duration by a value near to the derivative of the scroll
Michael Jurka20b7ca92011-06-07 20:09:16 -07002125 // interpolator at zero, ie. 5. We use 4 to make it a little slower.
2126 duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
Adam Cohene0f66b52010-11-23 15:06:07 -08002127
2128 snapToPage(whichPage, delta, duration);
Michael Jurka0142d492010-08-25 17:46:15 -07002129 }
2130
2131 protected void snapToPage(int whichPage) {
Winson Chung5f2aa4e2010-08-20 14:49:25 -07002132 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07002133 }
2134
Adam Cohen7d30a372013-07-01 17:03:59 -07002135 protected void snapToPageImmediately(int whichPage) {
2136 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION, true);
2137 }
2138
Michael Jurka0142d492010-08-25 17:46:15 -07002139 protected void snapToPage(int whichPage, int duration) {
Adam Cohen7d30a372013-07-01 17:03:59 -07002140 snapToPage(whichPage, duration, false);
2141 }
2142
2143 protected void snapToPage(int whichPage, int duration, boolean immediate) {
Winson Chung86f77532010-08-24 11:08:22 -07002144 whichPage = Math.max(0, Math.min(whichPage, getPageCount() - 1));
Winson Chung321e9ee2010-08-09 13:37:56 -07002145
Adam Cohenedb40762013-07-18 16:45:45 -07002146 int newX = getScrollForPage(whichPage);
Adam Cohen68d73932010-11-15 10:50:58 -08002147 final int sX = mUnboundedScrollX;
Winson Chung321e9ee2010-08-09 13:37:56 -07002148 final int delta = newX - sX;
Adam Cohen7d30a372013-07-01 17:03:59 -07002149 snapToPage(whichPage, delta, duration, immediate);
Michael Jurka0142d492010-08-25 17:46:15 -07002150 }
2151
2152 protected void snapToPage(int whichPage, int delta, int duration) {
Adam Cohen7d30a372013-07-01 17:03:59 -07002153 snapToPage(whichPage, delta, duration, false);
2154 }
Michael Jurka0142d492010-08-25 17:46:15 -07002155
Adam Cohen7d30a372013-07-01 17:03:59 -07002156 protected void snapToPage(int whichPage, int delta, int duration, boolean immediate) {
2157 mNextPage = whichPage;
Michael Jurka0142d492010-08-25 17:46:15 -07002158 View focusedChild = getFocusedChild();
2159 if (focusedChild != null && whichPage != mCurrentPage &&
Adam Cohen22f823d2011-09-01 17:22:18 -07002160 focusedChild == getPageAt(mCurrentPage)) {
Michael Jurka0142d492010-08-25 17:46:15 -07002161 focusedChild.clearFocus();
2162 }
2163
Adam Cohen53805212013-10-01 10:39:23 -07002164 sendScrollAccessibilityEvent();
2165
Michael Jurka0142d492010-08-25 17:46:15 -07002166 pageBeginMoving();
Winson Chung321e9ee2010-08-09 13:37:56 -07002167 awakenScrollBars(duration);
Adam Cohen7d30a372013-07-01 17:03:59 -07002168 if (immediate) {
2169 duration = 0;
2170 } else if (duration == 0) {
Winson Chung321e9ee2010-08-09 13:37:56 -07002171 duration = Math.abs(delta);
2172 }
2173
Adam Cohenf358a4b2013-07-23 16:47:31 -07002174 if (!mScroller.isFinished()) {
2175 mScroller.abortAnimation();
2176 }
Adam Cohen68d73932010-11-15 10:50:58 -08002177 mScroller.startScroll(mUnboundedScrollX, 0, delta, 0, duration);
Winson Chung80baf5a2010-08-09 16:03:15 -07002178
Michael Jurka0142d492010-08-25 17:46:15 -07002179 notifyPageSwitchListener();
Adam Cohen7d30a372013-07-01 17:03:59 -07002180
2181 // Trigger a compute() to finish switching pages if necessary
2182 if (immediate) {
2183 computeScroll();
2184 }
2185
Winson Chung9c0565f2013-07-19 13:49:06 -07002186 // Defer loading associated pages until the scroll settles
2187 mDeferLoadAssociatedPagesUntilScrollCompletes = true;
2188
Adam Cohen7d30a372013-07-01 17:03:59 -07002189 mForceScreenScrolled = true;
Winson Chung321e9ee2010-08-09 13:37:56 -07002190 invalidate();
2191 }
2192
Winson Chung321e9ee2010-08-09 13:37:56 -07002193 public void scrollLeft() {
Adam Cohen2bf63d52013-09-29 17:46:49 -07002194 if (getNextPage() > 0) snapToPage(getNextPage() - 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07002195 }
2196
2197 public void scrollRight() {
Adam Cohen2bf63d52013-09-29 17:46:49 -07002198 if (getNextPage() < getChildCount() -1) snapToPage(getNextPage() + 1);
Winson Chung321e9ee2010-08-09 13:37:56 -07002199 }
2200
Winson Chung86f77532010-08-24 11:08:22 -07002201 public int getPageForView(View v) {
Winson Chung321e9ee2010-08-09 13:37:56 -07002202 int result = -1;
2203 if (v != null) {
2204 ViewParent vp = v.getParent();
2205 int count = getChildCount();
2206 for (int i = 0; i < count; i++) {
Adam Cohen22f823d2011-09-01 17:22:18 -07002207 if (vp == getPageAt(i)) {
Winson Chung321e9ee2010-08-09 13:37:56 -07002208 return i;
2209 }
2210 }
2211 }
2212 return result;
2213 }
2214
2215 /**
2216 * @return True is long presses are still allowed for the current touch
2217 */
2218 public boolean allowLongPress() {
2219 return mAllowLongPress;
2220 }
2221
Adam Cohendbdff6b2013-09-18 19:09:15 -07002222 @Override
2223 public boolean performLongClick() {
2224 mCancelTap = true;
2225 return super.performLongClick();
2226 }
2227
Michael Jurka0142d492010-08-25 17:46:15 -07002228 /**
2229 * Set true to allow long-press events to be triggered, usually checked by
2230 * {@link Launcher} to accept or block dpad-initiated long-presses.
2231 */
2232 public void setAllowLongPress(boolean allowLongPress) {
2233 mAllowLongPress = allowLongPress;
2234 }
2235
Winson Chung321e9ee2010-08-09 13:37:56 -07002236 public static class SavedState extends BaseSavedState {
Winson Chung86f77532010-08-24 11:08:22 -07002237 int currentPage = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -07002238
2239 SavedState(Parcelable superState) {
2240 super(superState);
2241 }
2242
2243 private SavedState(Parcel in) {
2244 super(in);
Winson Chung86f77532010-08-24 11:08:22 -07002245 currentPage = in.readInt();
Winson Chung321e9ee2010-08-09 13:37:56 -07002246 }
2247
2248 @Override
2249 public void writeToParcel(Parcel out, int flags) {
2250 super.writeToParcel(out, flags);
Winson Chung86f77532010-08-24 11:08:22 -07002251 out.writeInt(currentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07002252 }
2253
2254 public static final Parcelable.Creator<SavedState> CREATOR =
2255 new Parcelable.Creator<SavedState>() {
2256 public SavedState createFromParcel(Parcel in) {
2257 return new SavedState(in);
2258 }
2259
2260 public SavedState[] newArray(int size) {
2261 return new SavedState[size];
2262 }
2263 };
2264 }
2265
Winson Chungf314b0e2011-08-16 11:54:27 -07002266 protected void loadAssociatedPages(int page) {
2267 loadAssociatedPages(page, false);
2268 }
2269 protected void loadAssociatedPages(int page, boolean immediateAndOnly) {
Michael Jurka0142d492010-08-25 17:46:15 -07002270 if (mContentIsRefreshable) {
2271 final int count = getChildCount();
2272 if (page < count) {
Winson Chunge3193b92010-09-10 11:44:42 -07002273 int lowerPageBound = getAssociatedLowerPageBound(page);
2274 int upperPageBound = getAssociatedUpperPageBound(page);
Winson Chung785d2eb2011-04-14 16:08:02 -07002275 if (DEBUG) Log.d(TAG, "loadAssociatedPages: " + lowerPageBound + "/"
2276 + upperPageBound);
Michael Jurka0cad1112011-11-16 20:43:29 -08002277 // First, clear any pages that should no longer be loaded
2278 for (int i = 0; i < count; ++i) {
2279 Page layout = (Page) getPageAt(i);
Michael Jurka2a4b1a82011-12-07 14:00:02 -08002280 if ((i < lowerPageBound) || (i > upperPageBound)) {
Michael Jurka0cad1112011-11-16 20:43:29 -08002281 if (layout.getPageChildCount() > 0) {
2282 layout.removeAllViewsOnPage();
2283 }
2284 mDirtyPageContent.set(i, true);
2285 }
2286 }
2287 // Next, load any new pages
Michael Jurka0142d492010-08-25 17:46:15 -07002288 for (int i = 0; i < count; ++i) {
Winson Chungf314b0e2011-08-16 11:54:27 -07002289 if ((i != page) && immediateAndOnly) {
2290 continue;
2291 }
Michael Jurka0142d492010-08-25 17:46:15 -07002292 if (lowerPageBound <= i && i <= upperPageBound) {
2293 if (mDirtyPageContent.get(i)) {
Winson Chungf314b0e2011-08-16 11:54:27 -07002294 syncPageItems(i, (i == page) && immediateAndOnly);
Michael Jurka0142d492010-08-25 17:46:15 -07002295 mDirtyPageContent.set(i, false);
2296 }
Winson Chung86f77532010-08-24 11:08:22 -07002297 }
Winson Chung80baf5a2010-08-09 16:03:15 -07002298 }
2299 }
Winson Chung80baf5a2010-08-09 16:03:15 -07002300 }
2301 }
2302
Winson Chunge3193b92010-09-10 11:44:42 -07002303 protected int getAssociatedLowerPageBound(int page) {
2304 return Math.max(0, page - 1);
2305 }
2306 protected int getAssociatedUpperPageBound(int page) {
2307 final int count = getChildCount();
2308 return Math.min(page + 1, count - 1);
2309 }
2310
Winson Chung86f77532010-08-24 11:08:22 -07002311 /**
2312 * This method is called ONLY to synchronize the number of pages that the paged view has.
2313 * To actually fill the pages with information, implement syncPageItems() below. It is
2314 * guaranteed that syncPageItems() will be called for a particular page before it is shown,
2315 * and therefore, individual page items do not need to be updated in this method.
2316 */
Winson Chung321e9ee2010-08-09 13:37:56 -07002317 public abstract void syncPages();
Winson Chung86f77532010-08-24 11:08:22 -07002318
2319 /**
2320 * This method is called to synchronize the items that are on a particular page. If views on
2321 * the page can be reused, then they should be updated within this method.
2322 */
Winson Chungf314b0e2011-08-16 11:54:27 -07002323 public abstract void syncPageItems(int page, boolean immediate);
Winson Chung86f77532010-08-24 11:08:22 -07002324
Patrick Dubroy244d74c2011-05-19 16:48:48 -07002325 protected void invalidatePageData() {
Winson Chungf314b0e2011-08-16 11:54:27 -07002326 invalidatePageData(-1, false);
Winson Chung5a808352011-06-27 19:08:49 -07002327 }
2328 protected void invalidatePageData(int currentPage) {
Winson Chungf314b0e2011-08-16 11:54:27 -07002329 invalidatePageData(currentPage, false);
2330 }
2331 protected void invalidatePageData(int currentPage, boolean immediateAndOnly) {
Winson Chungf0ea4d32011-06-06 14:27:16 -07002332 if (!mIsDataReady) {
2333 return;
2334 }
2335
Michael Jurka0142d492010-08-25 17:46:15 -07002336 if (mContentIsRefreshable) {
Adam Cohen0cd3b642011-10-14 14:58:00 -07002337 // Force all scrolling-related behavior to end
Adam Cohen4fe4c932013-10-28 16:02:34 -07002338 forceFinishScroller();
Adam Cohen0cd3b642011-10-14 14:58:00 -07002339
Michael Jurka0142d492010-08-25 17:46:15 -07002340 // Update all the pages
2341 syncPages();
Winson Chung86f77532010-08-24 11:08:22 -07002342
Winson Chung5a808352011-06-27 19:08:49 -07002343 // We must force a measure after we've loaded the pages to update the content width and
2344 // to determine the full scroll width
2345 measure(MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY),
2346 MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY));
2347
2348 // Set a new page as the current page if necessary
2349 if (currentPage > -1) {
Winson Chung5afbf7b2011-07-25 11:53:08 -07002350 setCurrentPage(Math.min(getPageCount() - 1, currentPage));
Winson Chung5a808352011-06-27 19:08:49 -07002351 }
2352
Michael Jurka0142d492010-08-25 17:46:15 -07002353 // Mark each of the pages as dirty
2354 final int count = getChildCount();
2355 mDirtyPageContent.clear();
2356 for (int i = 0; i < count; ++i) {
2357 mDirtyPageContent.add(true);
2358 }
2359
2360 // Load any pages that are necessary for the current window of views
Winson Chungf314b0e2011-08-16 11:54:27 -07002361 loadAssociatedPages(mCurrentPage, immediateAndOnly);
Michael Jurka0142d492010-08-25 17:46:15 -07002362 requestLayout();
Winson Chung86f77532010-08-24 11:08:22 -07002363 }
Adam Cohen06559042013-09-29 18:30:56 -07002364 if (isPageMoving()) {
2365 // If the page is moving, then snap it to the final position to ensure we don't get
2366 // stuck between pages
2367 snapToDestination();
2368 }
Winson Chung321e9ee2010-08-09 13:37:56 -07002369 }
Winson Chung007c6982011-06-14 13:27:53 -07002370
Adam Cohen7d30a372013-07-01 17:03:59 -07002371 // Animate the drag view back to the original position
2372 void animateDragViewToOriginalPosition() {
2373 if (mDragView != null) {
2374 AnimatorSet anim = new AnimatorSet();
2375 anim.setDuration(REORDERING_DROP_REPOSITION_DURATION);
2376 anim.playTogether(
2377 ObjectAnimator.ofFloat(mDragView, "translationX", 0f),
Adam Cohenf358a4b2013-07-23 16:47:31 -07002378 ObjectAnimator.ofFloat(mDragView, "translationY", 0f),
2379 ObjectAnimator.ofFloat(mDragView, "scaleX", 1f),
2380 ObjectAnimator.ofFloat(mDragView, "scaleY", 1f));
Adam Cohen7d30a372013-07-01 17:03:59 -07002381 anim.addListener(new AnimatorListenerAdapter() {
2382 @Override
2383 public void onAnimationEnd(Animator animation) {
2384 onPostReorderingAnimationCompleted();
2385 }
2386 });
2387 anim.start();
2388 }
Winson Chung3ac74c52011-06-30 17:39:37 -07002389 }
2390
Adam Cohen7d30a372013-07-01 17:03:59 -07002391 protected void onStartReordering() {
2392 // Set the touch state to reordering (allows snapping to pages, dragging a child, etc.)
2393 mTouchState = TOUCH_STATE_REORDERING;
2394 mIsReordering = true;
2395
Adam Cohen7d30a372013-07-01 17:03:59 -07002396 // We must invalidate to trigger a redraw to update the layers such that the drag view
2397 // is always drawn on top
2398 invalidate();
2399 }
2400
2401 private void onPostReorderingAnimationCompleted() {
2402 // Trigger the callback when reordering has settled
2403 --mPostReorderingPreZoomInRemainingAnimationCount;
2404 if (mPostReorderingPreZoomInRunnable != null &&
2405 mPostReorderingPreZoomInRemainingAnimationCount == 0) {
2406 mPostReorderingPreZoomInRunnable.run();
2407 mPostReorderingPreZoomInRunnable = null;
2408 }
2409 }
2410
2411 protected void onEndReordering() {
2412 mIsReordering = false;
Adam Cohen7d30a372013-07-01 17:03:59 -07002413 }
2414
Adam Cohenf358a4b2013-07-23 16:47:31 -07002415 public boolean startReordering(View v) {
Adam Cohen93c97562013-09-26 13:48:01 -07002416 int dragViewIndex = indexOfChild(v);
2417
2418 if (mTouchState != TOUCH_STATE_REST) return false;
2419
Adam Cohen7d30a372013-07-01 17:03:59 -07002420 mTempVisiblePagesRange[0] = 0;
2421 mTempVisiblePagesRange[1] = getPageCount() - 1;
Adam Cohenf358a4b2013-07-23 16:47:31 -07002422 getOverviewModePages(mTempVisiblePagesRange);
Adam Cohen7d30a372013-07-01 17:03:59 -07002423 mReorderingStarted = true;
2424
2425 // Check if we are within the reordering range
2426 if (mTempVisiblePagesRange[0] <= dragViewIndex &&
Adam Cohenf358a4b2013-07-23 16:47:31 -07002427 dragViewIndex <= mTempVisiblePagesRange[1]) {
2428 // Find the drag view under the pointer
2429 mDragView = getChildAt(dragViewIndex);
2430 mDragView.animate().scaleX(1.15f).scaleY(1.15f).setDuration(100).start();
2431 mDragViewBaselineLeft = mDragView.getLeft();
2432 disableFreeScroll(-1);
2433 onStartReordering();
Adam Cohen7d30a372013-07-01 17:03:59 -07002434 return true;
2435 }
2436 return false;
2437 }
2438
2439 boolean isReordering(boolean testTouchState) {
2440 boolean state = mIsReordering;
2441 if (testTouchState) {
2442 state &= (mTouchState == TOUCH_STATE_REORDERING);
2443 }
2444 return state;
2445 }
2446 void endReordering() {
2447 // For simplicity, we call endReordering sometimes even if reordering was never started.
2448 // In that case, we don't want to do anything.
2449 if (!mReorderingStarted) return;
2450 mReorderingStarted = false;
2451
2452 // If we haven't flung-to-delete the current child, then we just animate the drag view
2453 // back into position
2454 final Runnable onCompleteRunnable = new Runnable() {
2455 @Override
2456 public void run() {
2457 onEndReordering();
2458 }
2459 };
2460 if (!mDeferringForDelete) {
2461 mPostReorderingPreZoomInRunnable = new Runnable() {
2462 public void run() {
Adam Cohenf358a4b2013-07-23 16:47:31 -07002463 onCompleteRunnable.run();
2464 enableFreeScroll();
Adam Cohen7d30a372013-07-01 17:03:59 -07002465 };
2466 };
2467
2468 mPostReorderingPreZoomInRemainingAnimationCount =
2469 NUM_ANIMATIONS_RUNNING_BEFORE_ZOOM_OUT;
2470 // Snap to the current page
2471 snapToPage(indexOfChild(mDragView), 0);
2472 // Animate the drag view back to the front position
2473 animateDragViewToOriginalPosition();
2474 } else {
2475 // Handled in post-delete-animation-callbacks
2476 }
2477 }
2478
Adam Cohen7d30a372013-07-01 17:03:59 -07002479 /*
2480 * Flinging to delete - IN PROGRESS
2481 */
2482 private PointF isFlingingToDelete() {
2483 ViewConfiguration config = ViewConfiguration.get(getContext());
2484 mVelocityTracker.computeCurrentVelocity(1000, config.getScaledMaximumFlingVelocity());
2485
2486 if (mVelocityTracker.getYVelocity() < mFlingToDeleteThresholdVelocity) {
2487 // Do a quick dot product test to ensure that we are flinging upwards
2488 PointF vel = new PointF(mVelocityTracker.getXVelocity(),
2489 mVelocityTracker.getYVelocity());
2490 PointF upVec = new PointF(0f, -1f);
2491 float theta = (float) Math.acos(((vel.x * upVec.x) + (vel.y * upVec.y)) /
2492 (vel.length() * upVec.length()));
2493 if (theta <= Math.toRadians(FLING_TO_DELETE_MAX_FLING_DEGREES)) {
2494 return vel;
2495 }
2496 }
2497 return null;
2498 }
2499
2500 /**
2501 * Creates an animation from the current drag view along its current velocity vector.
2502 * For this animation, the alpha runs for a fixed duration and we update the position
2503 * progressively.
2504 */
2505 private static class FlingAlongVectorAnimatorUpdateListener implements AnimatorUpdateListener {
2506 private View mDragView;
2507 private PointF mVelocity;
2508 private Rect mFrom;
2509 private long mPrevTime;
2510 private float mFriction;
2511
2512 private final TimeInterpolator mAlphaInterpolator = new DecelerateInterpolator(0.75f);
2513
2514 public FlingAlongVectorAnimatorUpdateListener(View dragView, PointF vel, Rect from,
2515 long startTime, float friction) {
2516 mDragView = dragView;
2517 mVelocity = vel;
2518 mFrom = from;
2519 mPrevTime = startTime;
2520 mFriction = 1f - (mDragView.getResources().getDisplayMetrics().density * friction);
2521 }
2522
2523 @Override
2524 public void onAnimationUpdate(ValueAnimator animation) {
2525 float t = ((Float) animation.getAnimatedValue()).floatValue();
2526 long curTime = AnimationUtils.currentAnimationTimeMillis();
2527
2528 mFrom.left += (mVelocity.x * (curTime - mPrevTime) / 1000f);
2529 mFrom.top += (mVelocity.y * (curTime - mPrevTime) / 1000f);
2530
2531 mDragView.setTranslationX(mFrom.left);
2532 mDragView.setTranslationY(mFrom.top);
2533 mDragView.setAlpha(1f - mAlphaInterpolator.getInterpolation(t));
2534
2535 mVelocity.x *= mFriction;
2536 mVelocity.y *= mFriction;
2537 mPrevTime = curTime;
2538 }
2539 };
2540
2541 private static final int ANIM_TAG_KEY = 100;
2542
2543 private Runnable createPostDeleteAnimationRunnable(final View dragView) {
2544 return new Runnable() {
2545 @Override
2546 public void run() {
2547 int dragViewIndex = indexOfChild(dragView);
2548
2549 // For each of the pages around the drag view, animate them from the previous
2550 // position to the new position in the layout (as a result of the drag view moving
2551 // in the layout)
2552 // NOTE: We can make an assumption here because we have side-bound pages that we
2553 // will always have pages to animate in from the left
Adam Cohenf358a4b2013-07-23 16:47:31 -07002554 getOverviewModePages(mTempVisiblePagesRange);
Adam Cohen7d30a372013-07-01 17:03:59 -07002555 boolean isLastWidgetPage = (mTempVisiblePagesRange[0] == mTempVisiblePagesRange[1]);
2556 boolean slideFromLeft = (isLastWidgetPage ||
2557 dragViewIndex > mTempVisiblePagesRange[0]);
2558
2559 // Setup the scroll to the correct page before we swap the views
2560 if (slideFromLeft) {
2561 snapToPageImmediately(dragViewIndex - 1);
2562 }
2563
2564 int firstIndex = (isLastWidgetPage ? 0 : mTempVisiblePagesRange[0]);
2565 int lastIndex = Math.min(mTempVisiblePagesRange[1], getPageCount() - 1);
2566 int lowerIndex = (slideFromLeft ? firstIndex : dragViewIndex + 1 );
2567 int upperIndex = (slideFromLeft ? dragViewIndex - 1 : lastIndex);
2568 ArrayList<Animator> animations = new ArrayList<Animator>();
2569 for (int i = lowerIndex; i <= upperIndex; ++i) {
2570 View v = getChildAt(i);
2571 // dragViewIndex < pageUnderPointIndex, so after we remove the
2572 // drag view all subsequent views to pageUnderPointIndex will
2573 // shift down.
2574 int oldX = 0;
2575 int newX = 0;
2576 if (slideFromLeft) {
2577 if (i == 0) {
Adam Cohen0cd0eba2013-10-28 14:22:25 -07002578 int pageSpace = (getViewportWidth() - getChildWidth(i)) / 2;
Adam Cohen7d30a372013-07-01 17:03:59 -07002579 // Simulate the page being offscreen with the page spacing
2580 oldX = getViewportOffsetX() + getChildOffset(i) - getChildWidth(i)
Adam Cohen0cd0eba2013-10-28 14:22:25 -07002581 - pageSpace;
Adam Cohen7d30a372013-07-01 17:03:59 -07002582 } else {
2583 oldX = getViewportOffsetX() + getChildOffset(i - 1);
2584 }
2585 newX = getViewportOffsetX() + getChildOffset(i);
2586 } else {
2587 oldX = getChildOffset(i) - getChildOffset(i - 1);
2588 newX = 0;
2589 }
2590
2591 // Animate the view translation from its old position to its new
2592 // position
2593 AnimatorSet anim = (AnimatorSet) v.getTag();
2594 if (anim != null) {
2595 anim.cancel();
2596 }
2597
2598 // Note: Hacky, but we want to skip any optimizations to not draw completely
2599 // hidden views
2600 v.setAlpha(Math.max(v.getAlpha(), 0.01f));
2601 v.setTranslationX(oldX - newX);
2602 anim = new AnimatorSet();
2603 anim.playTogether(
2604 ObjectAnimator.ofFloat(v, "translationX", 0f),
2605 ObjectAnimator.ofFloat(v, "alpha", 1f));
2606 animations.add(anim);
2607 v.setTag(ANIM_TAG_KEY, anim);
2608 }
2609
2610 AnimatorSet slideAnimations = new AnimatorSet();
2611 slideAnimations.playTogether(animations);
2612 slideAnimations.setDuration(DELETE_SLIDE_IN_SIDE_PAGE_DURATION);
2613 slideAnimations.addListener(new AnimatorListenerAdapter() {
2614 @Override
2615 public void onAnimationEnd(Animator animation) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07002616 mDeferringForDelete = false;
2617 onEndReordering();
2618 onRemoveViewAnimationCompleted();
Adam Cohen7d30a372013-07-01 17:03:59 -07002619 }
2620 });
2621 slideAnimations.start();
2622
2623 removeView(dragView);
2624 onRemoveView(dragView, true);
2625 }
2626 };
2627 }
2628
2629 public void onFlingToDelete(PointF vel) {
2630 final long startTime = AnimationUtils.currentAnimationTimeMillis();
2631
2632 // NOTE: Because it takes time for the first frame of animation to actually be
2633 // called and we expect the animation to be a continuation of the fling, we have
2634 // to account for the time that has elapsed since the fling finished. And since
2635 // we don't have a startDelay, we will always get call to update when we call
2636 // start() (which we want to ignore).
2637 final TimeInterpolator tInterpolator = new TimeInterpolator() {
2638 private int mCount = -1;
2639 private long mStartTime;
2640 private float mOffset;
2641 /* Anonymous inner class ctor */ {
2642 mStartTime = startTime;
2643 }
2644
2645 @Override
2646 public float getInterpolation(float t) {
2647 if (mCount < 0) {
2648 mCount++;
2649 } else if (mCount == 0) {
2650 mOffset = Math.min(0.5f, (float) (AnimationUtils.currentAnimationTimeMillis() -
2651 mStartTime) / FLING_TO_DELETE_FADE_OUT_DURATION);
2652 mCount++;
2653 }
2654 return Math.min(1f, mOffset + t);
2655 }
2656 };
2657
2658 final Rect from = new Rect();
2659 final View dragView = mDragView;
2660 from.left = (int) dragView.getTranslationX();
2661 from.top = (int) dragView.getTranslationY();
2662 AnimatorUpdateListener updateCb = new FlingAlongVectorAnimatorUpdateListener(dragView, vel,
2663 from, startTime, FLING_TO_DELETE_FRICTION);
2664
2665 final Runnable onAnimationEndRunnable = createPostDeleteAnimationRunnable(dragView);
2666
2667 // Create and start the animation
2668 ValueAnimator mDropAnim = new ValueAnimator();
2669 mDropAnim.setInterpolator(tInterpolator);
2670 mDropAnim.setDuration(FLING_TO_DELETE_FADE_OUT_DURATION);
2671 mDropAnim.setFloatValues(0f, 1f);
2672 mDropAnim.addUpdateListener(updateCb);
2673 mDropAnim.addListener(new AnimatorListenerAdapter() {
2674 public void onAnimationEnd(Animator animation) {
2675 onAnimationEndRunnable.run();
2676 }
2677 });
2678 mDropAnim.start();
2679 mDeferringForDelete = true;
2680 }
2681
2682 /* Drag to delete */
2683 private boolean isHoveringOverDeleteDropTarget(int x, int y) {
2684 if (mDeleteDropTarget != null) {
2685 mAltTmpRect.set(0, 0, 0, 0);
2686 View parent = (View) mDeleteDropTarget.getParent();
2687 if (parent != null) {
2688 parent.getGlobalVisibleRect(mAltTmpRect);
2689 }
2690 mDeleteDropTarget.getGlobalVisibleRect(mTmpRect);
2691 mTmpRect.offset(-mAltTmpRect.left, -mAltTmpRect.top);
2692 return mTmpRect.contains(x, y);
2693 }
2694 return false;
2695 }
2696
2697 protected void setPageHoveringOverDeleteDropTarget(int viewIndex, boolean isHovering) {}
2698
2699 private void onDropToDelete() {
2700 final View dragView = mDragView;
2701
2702 final float toScale = 0f;
2703 final float toAlpha = 0f;
2704
2705 // Create and start the complex animation
2706 ArrayList<Animator> animations = new ArrayList<Animator>();
2707 AnimatorSet motionAnim = new AnimatorSet();
2708 motionAnim.setInterpolator(new DecelerateInterpolator(2));
2709 motionAnim.playTogether(
2710 ObjectAnimator.ofFloat(dragView, "scaleX", toScale),
2711 ObjectAnimator.ofFloat(dragView, "scaleY", toScale));
2712 animations.add(motionAnim);
2713
2714 AnimatorSet alphaAnim = new AnimatorSet();
2715 alphaAnim.setInterpolator(new LinearInterpolator());
2716 alphaAnim.playTogether(
2717 ObjectAnimator.ofFloat(dragView, "alpha", toAlpha));
2718 animations.add(alphaAnim);
2719
2720 final Runnable onAnimationEndRunnable = createPostDeleteAnimationRunnable(dragView);
2721
2722 AnimatorSet anim = new AnimatorSet();
2723 anim.playTogether(animations);
2724 anim.setDuration(DRAG_TO_DELETE_FADE_OUT_DURATION);
2725 anim.addListener(new AnimatorListenerAdapter() {
2726 public void onAnimationEnd(Animator animation) {
2727 onAnimationEndRunnable.run();
2728 }
2729 });
2730 anim.start();
2731
2732 mDeferringForDelete = true;
Winson Chung007c6982011-06-14 13:27:53 -07002733 }
Winson Chung6a0f57d2011-06-29 20:10:49 -07002734
2735 /* Accessibility */
2736 @Override
2737 public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
2738 super.onInitializeAccessibilityNodeInfo(info);
Svetoslav Ganov08055f62012-05-15 11:06:36 -07002739 info.setScrollable(getPageCount() > 1);
2740 if (getCurrentPage() < getPageCount() - 1) {
2741 info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD);
2742 }
2743 if (getCurrentPage() > 0) {
2744 info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD);
2745 }
Winson Chung6a0f57d2011-06-29 20:10:49 -07002746 }
2747
2748 @Override
Alan Viverette254139a2013-10-08 13:13:46 -07002749 public void sendAccessibilityEvent(int eventType) {
2750 // Don't let the view send real scroll events.
2751 if (eventType != AccessibilityEvent.TYPE_VIEW_SCROLLED) {
2752 super.sendAccessibilityEvent(eventType);
2753 }
2754 }
2755
2756 @Override
Winson Chung6a0f57d2011-06-29 20:10:49 -07002757 public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
2758 super.onInitializeAccessibilityEvent(event);
2759 event.setScrollable(true);
Winson Chung6a0f57d2011-06-29 20:10:49 -07002760 }
2761
Svetoslav Ganov08055f62012-05-15 11:06:36 -07002762 @Override
2763 public boolean performAccessibilityAction(int action, Bundle arguments) {
2764 if (super.performAccessibilityAction(action, arguments)) {
2765 return true;
2766 }
2767 switch (action) {
2768 case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: {
2769 if (getCurrentPage() < getPageCount() - 1) {
2770 scrollRight();
2771 return true;
2772 }
2773 } break;
2774 case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: {
2775 if (getCurrentPage() > 0) {
2776 scrollLeft();
2777 return true;
2778 }
2779 } break;
2780 }
2781 return false;
2782 }
2783
Adam Cohen0ffac432013-07-10 11:19:26 -07002784 protected String getCurrentPageDescription() {
2785 return String.format(getContext().getString(R.string.default_scroll_format),
2786 getNextPage() + 1, getChildCount());
2787 }
2788
Winson Chungd11265e2011-08-30 13:37:23 -07002789 @Override
2790 public boolean onHoverEvent(android.view.MotionEvent event) {
2791 return true;
2792 }
Adam Cohen5084cba2013-09-03 12:01:16 -07002793}