blob: 204913a96caf0f5d51a638b92b5fd5d0feb16b91 [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
Andras Kloczl55edfe52021-05-14 12:21:30 +020019import static androidx.annotation.VisibleForTesting.PACKAGE_PRIVATE;
Andras Kloczldbf577a2021-05-26 15:02:52 +020020
Sunny Goyalc39db732021-04-03 01:20:21 -070021import static com.android.launcher3.anim.Interpolators.SCROLL;
Sunny Goyal8b37c572020-03-31 12:12:14 -070022import static com.android.launcher3.compat.AccessibilityManagerCompat.isAccessibilityEnabled;
23import static com.android.launcher3.compat.AccessibilityManagerCompat.isObservedEventType;
Sunny Goyal8b37c572020-03-31 12:12:14 -070024import static com.android.launcher3.touch.OverScroll.OVERSCROLL_DAMP_FACTOR;
Sunny Goyal8b37c572020-03-31 12:12:14 -070025import static com.android.launcher3.touch.PagedOrientationHandler.VIEW_SCROLL_BY;
26import static com.android.launcher3.touch.PagedOrientationHandler.VIEW_SCROLL_TO;
27
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -070028import android.animation.LayoutTransition;
Sunny Goyalcf25b522015-07-09 00:01:18 -070029import android.annotation.SuppressLint;
Winson Chung321e9ee2010-08-09 13:37:56 -070030import android.content.Context;
Adam Cohen9c4949e2010-10-05 12:27:22 -070031import android.content.res.TypedArray;
Jon Miranda71cb80c2019-01-24 21:25:13 -080032import android.graphics.Canvas;
Winson Chung321e9ee2010-08-09 13:37:56 -070033import android.graphics.Rect;
Svetoslav Ganov08055f62012-05-15 11:06:36 -070034import android.os.Bundle;
Tony Wickhamd58c2d52018-05-04 12:10:55 -070035import android.provider.Settings;
Winson Chung321e9ee2010-08-09 13:37:56 -070036import android.util.AttributeSet;
Winson Chung785d2eb2011-04-14 16:08:02 -070037import android.util.Log;
Winson Chung185d7162011-02-28 13:47:29 -080038import android.view.InputDevice;
39import android.view.KeyEvent;
Winson Chung321e9ee2010-08-09 13:37:56 -070040import android.view.MotionEvent;
41import android.view.VelocityTracker;
42import android.view.View;
43import android.view.ViewConfiguration;
Sunny Goyal4ffec482016-02-09 11:28:52 -080044import android.view.ViewDebug;
Winson Chung321e9ee2010-08-09 13:37:56 -070045import android.view.ViewGroup;
46import android.view.ViewParent;
Winson Chung6a0f57d2011-06-29 20:10:49 -070047import android.view.accessibility.AccessibilityEvent;
48import android.view.accessibility.AccessibilityNodeInfo;
Sunny Goyalc39db732021-04-03 01:20:21 -070049import android.widget.OverScroller;
Vadim Trysheve6bbefb2018-04-03 13:38:06 -070050import android.widget.ScrollView;
Tony Wickhamf549dab2016-05-16 09:54:06 -070051
Tony Wickham62117d72020-03-26 16:56:26 -070052import androidx.annotation.Nullable;
Andras Kloczl55edfe52021-05-14 12:21:30 +020053import androidx.annotation.VisibleForTesting;
Tony Wickham62117d72020-03-26 16:56:26 -070054
Jon Miranda9e198662020-03-11 14:42:02 -070055import com.android.launcher3.compat.AccessibilityManagerCompat;
56import com.android.launcher3.config.FeatureFlags;
Jon Miranda9e198662020-03-11 14:42:02 -070057import com.android.launcher3.pageindicators.PageIndicator;
Jon Miranda9e198662020-03-11 14:42:02 -070058import com.android.launcher3.touch.PagedOrientationHandler;
59import com.android.launcher3.touch.PagedOrientationHandler.ChildBounds;
Sunny Goyalc39db732021-04-03 01:20:21 -070060import com.android.launcher3.util.EdgeEffectCompat;
Andras Kloczl55edfe52021-05-14 12:21:30 +020061import com.android.launcher3.util.IntSet;
Jon Miranda9e198662020-03-11 14:42:02 -070062import com.android.launcher3.util.Thunk;
Sunny Goyal8b37c572020-03-31 12:12:14 -070063import com.android.launcher3.views.ActivityContext;
Jon Miranda9e198662020-03-11 14:42:02 -070064
65import java.util.ArrayList;
Sunny Goyal59969372021-05-06 12:11:44 -070066import java.util.function.Consumer;
Jon Miranda9e198662020-03-11 14:42:02 -070067
Winson Chung321e9ee2010-08-09 13:37:56 -070068/**
69 * An abstraction of the original Workspace which supports browsing through a
Michael Jurka0142d492010-08-25 17:46:15 -070070 * sequential list of "pages"
Winson Chung321e9ee2010-08-09 13:37:56 -070071 */
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -080072public abstract class PagedView<T extends View & PageIndicator> extends ViewGroup {
Winson Chung321e9ee2010-08-09 13:37:56 -070073 private static final String TAG = "PagedView";
Winson Chung785d2eb2011-04-14 16:08:02 -070074 private static final boolean DEBUG = false;
Winson Chung4941f652020-06-18 15:11:53 -070075 public static final boolean DEBUG_FAILED_QUICKSWITCH = false;
Sunny Goyal20a13ff2018-03-13 16:44:00 -070076
Winson Chung4941f652020-06-18 15:11:53 -070077 public static final int ACTION_MOVE_ALLOW_EASY_FLING = MotionEvent.ACTION_MASK - 1;
Sunny Goyala7a5bf32020-01-05 15:35:29 +053078 public static final int INVALID_PAGE = -1;
Sunny Goyal20a13ff2018-03-13 16:44:00 -070079 protected static final ComputePageScrollsLogic SIMPLE_SCROLL_LOGIC = (v) -> v.getVisibility() != GONE;
Winson Chung321e9ee2010-08-09 13:37:56 -070080
Vadim Tryshevfedca432015-08-19 17:55:02 -070081 public static final int PAGE_SNAP_ANIMATION_DURATION = 750;
Winson Chung321e9ee2010-08-09 13:37:56 -070082
Adam Cohenb64cb5a2011-02-15 13:53:42 -080083 private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.33f;
Adam Cohen00481b32011-11-18 12:03:48 -080084 // The page is moved more than halfway, automatically move to the next page on touch up.
85 private static final float SIGNIFICANT_MOVE_THRESHOLD = 0.4f;
Adam Cohen68d73932010-11-15 10:50:58 -080086
Sunny Goyal8e2133b2015-05-06 13:39:07 -070087 private static final float MAX_SCROLL_PROGRESS = 1.0f;
88
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;
Winson Chung4941f652020-06-18 15:11:53 -070092 private static final int EASY_FLING_THRESHOLD_VELOCITY = 400;
Adam Cohen265b9a62011-12-07 14:37:18 -080093 private static final int MIN_SNAP_VELOCITY = 1500;
94 private static final int MIN_FLING_VELOCITY = 250;
95
Adam Cohenf358a4b2013-07-23 16:47:31 -070096 private boolean mFreeScroll = false;
Adam Cohenf358a4b2013-07-23 16:47:31 -070097
Winson Chung4941f652020-06-18 15:11:53 -070098 protected final int mFlingThresholdVelocity;
99 protected final int mEasyFlingThresholdVelocity;
100 protected final int mMinFlingVelocity;
101 protected final int mMinSnapVelocity;
Michael Jurka0142d492010-08-25 17:46:15 -0700102
Michael Jurka0142d492010-08-25 17:46:15 -0700103 protected boolean mFirstLayout = true;
104
Sunny Goyal4ffec482016-02-09 11:28:52 -0800105 @ViewDebug.ExportedProperty(category = "launcher")
Michael Jurka0142d492010-08-25 17:46:15 -0700106 protected int mCurrentPage;
Adam Cohene61a9a22013-06-11 15:45:31 -0700107
Sunny Goyal4ffec482016-02-09 11:28:52 -0800108 @ViewDebug.ExportedProperty(category = "launcher")
Michael Jurka0142d492010-08-25 17:46:15 -0700109 protected int mNextPage = INVALID_PAGE;
Vinit Nayaka406f722019-12-19 11:50:55 -0800110 protected int mMaxScroll;
111 protected int mMinScroll;
Sunny Goyalb7b01352018-08-09 12:31:20 -0700112 protected OverScroller mScroller;
Winson Chung321e9ee2010-08-09 13:37:56 -0700113 private VelocityTracker mVelocityTracker;
Sunny Goyale15e2a82017-12-15 13:05:42 -0800114 protected int mPageSpacing = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -0700115
116 private float mDownMotionX;
Adam Cohen7d30a372013-07-01 17:03:59 -0700117 private float mDownMotionY;
Vinit Nayaka406f722019-12-19 11:50:55 -0800118 private float mDownMotionPrimary;
119 private float mLastMotion;
120 private float mLastMotionRemainder;
121 private float mTotalMotion;
Winson Chung4941f652020-06-18 15:11:53 -0700122 // Used in special cases where the fling checks can be relaxed for an intentional gesture
123 private boolean mAllowEasyFling;
Sunny Goyalacd17df2020-04-03 15:58:45 -0700124 protected PagedOrientationHandler mOrientationHandler = PagedOrientationHandler.PORTRAIT;
Adam Cohenedb40762013-07-18 16:45:45 -0700125
Vadim Trysheve628c472018-05-16 14:28:18 -0700126 protected int[] mPageScrolls;
Sunny Goyalaad33592018-08-07 17:20:35 -0700127 private boolean mIsBeingDragged;
Adam Cohencae7f572013-11-04 14:42:52 -0800128
Winson Chung4941f652020-06-18 15:11:53 -0700129 // The amount of movement to begin scrolling
Michael Jurka7426c422010-11-11 15:23:47 -0800130 protected int mTouchSlop;
Winson Chung4941f652020-06-18 15:11:53 -0700131 // The amount of movement to begin paging
132 protected int mPageSlop;
Winson Chung321e9ee2010-08-09 13:37:56 -0700133 private int mMaximumVelocity;
Adam Cohen68d73932010-11-15 10:50:58 -0800134 protected boolean mAllowOverScroll = true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700135
Michael Jurka5f1c5092010-09-03 14:15:02 -0700136 protected static final int INVALID_POINTER = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -0700137
Michael Jurka5f1c5092010-09-03 14:15:02 -0700138 protected int mActivePointerId = INVALID_POINTER;
Winson Chung321e9ee2010-08-09 13:37:56 -0700139
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700140 protected boolean mIsPageInTransition = false;
Tony Wickham62117d72020-03-26 16:56:26 -0700141 private Runnable mOnPageTransitionEndCallback;
Patrick Dubroy1262e362010-10-06 15:49:50 -0700142
Winson Chungd2be3812013-07-16 11:11:32 -0700143 // Page Indicator
Adam Cohen091440a2015-03-18 14:16:05 -0700144 @Thunk int mPageIndicatorViewId;
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800145 protected T mPageIndicator;
Adam Cohen7d30a372013-07-01 17:03:59 -0700146
John Spurlock77e1f472013-09-11 10:09:51 -0400147 protected final Rect mInsets = new Rect();
Tony Wickhamdfb5cc92018-02-26 16:41:57 -0800148 protected boolean mIsRtl;
John Spurlock77e1f472013-09-11 10:09:51 -0400149
Sunny Goyal85a7fe02018-02-02 10:09:32 -0800150 // Similar to the platform implementation of isLayoutValid();
151 protected boolean mIsLayoutValid;
152
Vadim Tryshev528b9e02018-05-24 18:22:03 -0700153 private int[] mTmpIntPair = new int[2];
154
Sunny Goyalc39db732021-04-03 01:20:21 -0700155 protected EdgeEffectCompat mEdgeGlowLeft;
156 protected EdgeEffectCompat mEdgeGlowRight;
157
Winson Chung321e9ee2010-08-09 13:37:56 -0700158 public PagedView(Context context) {
159 this(context, null);
160 }
161
162 public PagedView(Context context, AttributeSet attrs) {
163 this(context, attrs, 0);
164 }
165
166 public PagedView(Context context, AttributeSet attrs, int defStyle) {
167 super(context, attrs, defStyle);
Winson Chungc9ca2982013-07-19 12:07:38 -0700168
Adam Cohen9c4949e2010-10-05 12:27:22 -0700169 TypedArray a = context.obtainStyledAttributes(attrs,
170 R.styleable.PagedView, defStyle, 0);
Winson Chungd2be3812013-07-16 11:11:32 -0700171 mPageIndicatorViewId = a.getResourceId(R.styleable.PagedView_pageIndicator, -1);
Adam Cohen9c4949e2010-10-05 12:27:22 -0700172 a.recycle();
173
Winson Chung321e9ee2010-08-09 13:37:56 -0700174 setHapticFeedbackEnabled(false);
Sunny Goyal70660032015-05-14 00:07:08 -0700175 mIsRtl = Utilities.isRtl(getResources());
Winson Chung321e9ee2010-08-09 13:37:56 -0700176
Sunny Goyalc39db732021-04-03 01:20:21 -0700177 mScroller = new OverScroller(context, SCROLL);
Winson Chung86f77532010-08-24 11:08:22 -0700178 mCurrentPage = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -0700179
Vinit Nayaka406f722019-12-19 11:50:55 -0800180 final ViewConfiguration configuration = ViewConfiguration.get(context);
Winson Chung4941f652020-06-18 15:11:53 -0700181 mTouchSlop = configuration.getScaledTouchSlop();
182 mPageSlop = configuration.getScaledPagingTouchSlop();
Winson Chung321e9ee2010-08-09 13:37:56 -0700183 mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
Adam Cohen265b9a62011-12-07 14:37:18 -0800184
Sunny Goyalcf25b522015-07-09 00:01:18 -0700185 float density = getResources().getDisplayMetrics().density;
186 mFlingThresholdVelocity = (int) (FLING_THRESHOLD_VELOCITY * density);
Winson Chung4941f652020-06-18 15:11:53 -0700187 mEasyFlingThresholdVelocity = (int) (EASY_FLING_THRESHOLD_VELOCITY * density);
Sunny Goyalcf25b522015-07-09 00:01:18 -0700188 mMinFlingVelocity = (int) (MIN_FLING_VELOCITY * density);
189 mMinSnapVelocity = (int) (MIN_SNAP_VELOCITY * density);
Sunny Goyala9f55462018-03-25 18:15:15 -0700190
Sunny Goyalc39db732021-04-03 01:20:21 -0700191 initEdgeEffect();
Sunny Goyaleaf7a952020-07-29 16:54:20 -0700192 setDefaultFocusHighlightEnabled(false);
Sunny Goyalc39db732021-04-03 01:20:21 -0700193 setWillNotDraw(false);
Winson Chung321e9ee2010-08-09 13:37:56 -0700194 }
195
Sunny Goyalc39db732021-04-03 01:20:21 -0700196 protected void initEdgeEffect() {
197 mEdgeGlowLeft = new EdgeEffectCompat(getContext());
198 mEdgeGlowRight = new EdgeEffectCompat(getContext());
Adam Cohenf9618852013-11-08 06:45:03 -0800199 }
200
Sunny Goyald0a6ae72016-06-16 12:29:03 -0700201 public void initParentViews(View parent) {
202 if (mPageIndicatorViewId > -1) {
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800203 mPageIndicator = parent.findViewById(mPageIndicatorViewId);
Sunny Goyalc64cfdd2016-05-18 14:12:02 -0700204 mPageIndicator.setMarkersCount(getChildCount());
Winson Chungd2be3812013-07-16 11:11:32 -0700205 }
206 }
207
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800208 public T getPageIndicator() {
Adam Cohenedb40762013-07-18 16:45:45 -0700209 return mPageIndicator;
210 }
211
Adam Cohen674531f2013-12-13 15:07:14 -0800212 /**
Tony Wickham29d853c2015-09-08 10:35:56 -0700213 * Returns the index of the currently displayed page. When in free scroll mode, this is the page
214 * that the user was on before entering free scroll mode (e.g. the home screen page they
Alex Chaub794ea62021-02-03 18:00:30 +0000215 * long-pressed on to enter the overview). Try using {@link #getDestinationPage()}
Tony Wickham29d853c2015-09-08 10:35:56 -0700216 * to get the page the user is currently scrolling over.
Winson Chung321e9ee2010-08-09 13:37:56 -0700217 */
Sunny Goyal83a8f042015-05-19 12:52:12 -0700218 public int getCurrentPage() {
Winson Chung86f77532010-08-24 11:08:22 -0700219 return mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700220 }
Adam Cohen7d30a372013-07-01 17:03:59 -0700221
Hyunyoung Songb76cd622015-04-16 14:34:09 -0700222 /**
223 * Returns the index of page to be shown immediately afterwards.
224 */
Vadim Tryshevfedca432015-08-19 17:55:02 -0700225 public int getNextPage() {
Winson Chung360e63f2012-04-27 13:48:05 -0700226 return (mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage;
227 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700228
Adam Cohenf9c184a2016-01-15 16:47:43 -0800229 public int getPageCount() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700230 return getChildCount();
231 }
232
Sunny Goyal83a8f042015-05-19 12:52:12 -0700233 public View getPageAt(int index) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700234 return getChildAt(index);
235 }
236
Adam Cohenae4f1552011-10-20 00:15:42 -0700237 protected int indexToPage(int index) {
238 return index;
239 }
240
Winson Chung321e9ee2010-08-09 13:37:56 -0700241 /**
Winson Chungbbc60d82010-11-11 16:34:41 -0800242 * Updates the scroll of the current page immediately to its final scroll position. We use this
243 * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of
244 * the previous tab page.
245 */
246 protected void updateCurrentPageScroll() {
Adam Cohen0ffac432013-07-10 11:19:26 -0700247 // If the current page is invalid, just reset the scroll position to zero
Vinit Nayaka406f722019-12-19 11:50:55 -0800248 int newPosition = 0;
Adam Cohen0ffac432013-07-10 11:19:26 -0700249 if (0 <= mCurrentPage && mCurrentPage < getPageCount()) {
Vinit Nayaka406f722019-12-19 11:50:55 -0800250 newPosition = getScrollForPage(mCurrentPage);
Adam Cohen0ffac432013-07-10 11:19:26 -0700251 }
Vinit Nayaka406f722019-12-19 11:50:55 -0800252 mOrientationHandler.set(this, VIEW_SCROLL_TO, newPosition);
Sunny Goyalc39db732021-04-03 01:20:21 -0700253 mScroller.startScroll(mScroller.getCurrX(), 0, newPosition - mScroller.getCurrX(), 0);
Sunny Goyalc82c6392018-06-06 15:39:13 -0700254 forceFinishScroller(true);
Winson Chungbbc60d82010-11-11 16:34:41 -0800255 }
256
Tony Wickhamf8d731a2021-05-26 14:58:13 -0700257 /**
258 * Immediately finishes any overscroll effect and jumps to the end of the scroller animation.
259 */
260 public void abortScrollerAnimation() {
261 mEdgeGlowLeft.finish();
262 mEdgeGlowRight.finish();
263 abortScrollerAnimation(true);
264 }
265
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700266 private void abortScrollerAnimation(boolean resetNextPage) {
Adam Cohen4fe4c932013-10-28 16:02:34 -0700267 mScroller.abortAnimation();
268 // We need to clean up the next page here to avoid computeScrollHelper from
269 // updating current page on the pass.
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700270 if (resetNextPage) {
271 mNextPage = INVALID_PAGE;
Sunny Goyal857b1b92018-03-05 10:49:05 -0800272 pageEndTransition();
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700273 }
Chet Haasebc2f0822012-10-26 17:59:53 -0700274 }
Adam Cohen4fe4c932013-10-28 16:02:34 -0700275
Tony Wickham8f7ead32016-04-07 18:46:44 -0700276 private void forceFinishScroller(boolean resetNextPage) {
Adam Cohen4fe4c932013-10-28 16:02:34 -0700277 mScroller.forceFinished(true);
278 // We need to clean up the next page here to avoid computeScrollHelper from
279 // updating current page on the pass.
Tony Wickham8f7ead32016-04-07 18:46:44 -0700280 if (resetNextPage) {
281 mNextPage = INVALID_PAGE;
Sunny Goyal857b1b92018-03-05 10:49:05 -0800282 pageEndTransition();
Tony Wickham8f7ead32016-04-07 18:46:44 -0700283 }
Adam Cohen4fe4c932013-10-28 16:02:34 -0700284 }
285
Adam Cohen6f127a62014-06-12 14:54:41 -0700286 private int validateNewPage(int newPage) {
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700287 newPage = ensureWithinScrollBounds(newPage);
Adam Cohen6f127a62014-06-12 14:54:41 -0700288 // Ensure that it is clamped by the actual set of children in all cases
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100289 newPage = Utilities.boundToRange(newPage, 0, getPageCount() - 1);
290
291 if (getPanelCount() > 1) {
292 // Always return left panel as new page
293 newPage = getLeftmostVisiblePageForIndex(newPage);
294 }
295 return newPage;
296 }
297
Andras Kloczl55edfe52021-05-14 12:21:30 +0200298 /**
299 * In most cases where panelCount is 1, this method will just return the page index that was
300 * passed in.
301 * But for example when two panel home is enabled we might need the leftmost visible page index
302 * because that page is the current page.
303 */
304 public int getLeftmostVisiblePageForIndex(int pageIndex) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100305 int panelCount = getPanelCount();
Andras Kloczl55edfe52021-05-14 12:21:30 +0200306 return pageIndex - pageIndex % panelCount;
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100307 }
308
309 /**
310 * Returns the number of pages that are shown at the same time.
311 */
312 protected int getPanelCount() {
313 return 1;
314 }
315
316 /**
Andras Kloczl55edfe52021-05-14 12:21:30 +0200317 * Returns an IntSet with the indices of the currently visible pages
318 */
319 @VisibleForTesting(otherwise = PACKAGE_PRIVATE)
320 public IntSet getVisiblePageIndices() {
321 IntSet visiblePageIndices = new IntSet();
322 int panelCount = getPanelCount();
323 int pageCount = getPageCount();
324
325 // If a device goes from one panel to two panel (i.e. unfolding a foldable device) while
326 // an odd indexed page is the current page, then the new leftmost visible page will be
327 // different from the old mCurrentPage.
328 int currentPage = getLeftmostVisiblePageForIndex(mCurrentPage);
329 for (int page = currentPage; page < currentPage + panelCount && page < pageCount; page++) {
330 visiblePageIndices.add(page);
331 }
332 return visiblePageIndices;
333 }
334
335 /**
Sunny Goyal59969372021-05-06 12:11:44 -0700336 * Executes the callback against each visible page
Andras Kloczl2bb51342021-03-20 01:13:45 +0100337 */
Sunny Goyal59969372021-05-06 12:11:44 -0700338 public void forEachVisiblePage(Consumer<View> callback) {
Andras Kloczl55edfe52021-05-14 12:21:30 +0200339 getVisiblePageIndices().forEach(pageIndex -> {
340 View page = getPageAt(pageIndex);
Andras Kloczl2bb51342021-03-20 01:13:45 +0100341 if (page != null) {
Sunny Goyal59969372021-05-06 12:11:44 -0700342 callback.accept(page);
Andras Kloczl2bb51342021-03-20 01:13:45 +0100343 }
Andras Kloczl55edfe52021-05-14 12:21:30 +0200344 });
Andras Kloczl2bb51342021-03-20 01:13:45 +0100345 }
346
347 /**
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100348 * Returns true if the view is on one of the current pages, false otherwise.
349 */
350 public boolean isVisible(View child) {
351 return getLeftmostVisiblePageForIndex(indexOfChild(child)) == mCurrentPage;
Adam Cohen6f127a62014-06-12 14:54:41 -0700352 }
353
Chet Haasebc2f0822012-10-26 17:59:53 -0700354 /**
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700355 * @return The closest page to the provided page that is within mMinScrollX and mMaxScrollX.
356 */
357 private int ensureWithinScrollBounds(int page) {
358 int dir = !mIsRtl ? 1 : - 1;
359 int currScroll = getScrollForPage(page);
360 int prevScroll;
Vinit Nayaka406f722019-12-19 11:50:55 -0800361 while (currScroll < mMinScroll) {
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700362 page += dir;
363 prevScroll = currScroll;
364 currScroll = getScrollForPage(page);
365 if (currScroll <= prevScroll) {
366 Log.e(TAG, "validateNewPage: failed to find a page > mMinScrollX");
367 break;
368 }
369 }
Vinit Nayaka406f722019-12-19 11:50:55 -0800370 while (currScroll > mMaxScroll) {
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700371 page -= dir;
372 prevScroll = currScroll;
373 currScroll = getScrollForPage(page);
374 if (currScroll >= prevScroll) {
375 Log.e(TAG, "validateNewPage: failed to find a page < mMaxScrollX");
376 break;
377 }
378 }
379 return page;
380 }
381
Tony Wickham03f27012019-04-25 14:22:54 -0700382 public void setCurrentPage(int currentPage) {
383 setCurrentPage(currentPage, INVALID_PAGE);
384 }
385
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700386 /**
Winson Chung86f77532010-08-24 11:08:22 -0700387 * Sets the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700388 */
Tony Wickham03f27012019-04-25 14:22:54 -0700389 public void setCurrentPage(int currentPage, int overridePrevPage) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800390 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -0700391 abortScrollerAnimation(true);
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800392 }
Michael Jurkad3ef3062010-11-23 16:23:58 -0800393 // don't introduce any checks like mCurrentPage == currentPage here-- if we change the
394 // the default
395 if (getChildCount() == 0) {
Patrick Dubroy72e0d342010-11-09 15:23:28 -0800396 return;
397 }
Tony Wickham03f27012019-04-25 14:22:54 -0700398 int prevPage = overridePrevPage != INVALID_PAGE ? overridePrevPage : mCurrentPage;
Adam Cohen6f127a62014-06-12 14:54:41 -0700399 mCurrentPage = validateNewPage(currentPage);
Winson Chung181c3dc2013-07-17 15:36:20 -0700400 updateCurrentPageScroll();
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700401 notifyPageSwitchListener(prevPage);
Winson Chunga12a2502010-12-20 14:41:35 -0800402 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -0700403 }
404
Winson Chung8c87cd82013-07-23 16:20:10 -0700405 /**
Adam Cohen674531f2013-12-13 15:07:14 -0800406 * Should be called whenever the page changes. In the case of a scroll, we wait until the page
407 * has settled.
408 */
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700409 protected void notifyPageSwitchListener(int prevPage) {
Adam Cohen674531f2013-12-13 15:07:14 -0800410 updatePageIndicator();
411 }
412
413 private void updatePageIndicator() {
Sunny Goyal4cbf0462014-08-28 16:19:39 -0700414 if (mPageIndicator != null) {
Tony Mak4f521af2018-03-15 16:37:34 +0000415 mPageIndicator.setActiveMarker(getNextPage());
Winson Chungd2be3812013-07-16 11:11:32 -0700416 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700417 }
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700418 protected void pageBeginTransition() {
419 if (!mIsPageInTransition) {
420 mIsPageInTransition = true;
421 onPageBeginTransition();
Michael Jurkad74c9842011-07-10 12:44:21 -0700422 }
Patrick Dubroy1262e362010-10-06 15:49:50 -0700423 }
424
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700425 protected void pageEndTransition() {
Sunny Goyal05b59c02021-04-29 13:55:40 -0700426 if (mIsPageInTransition && !mIsBeingDragged && mScroller.isFinished()
Sunny Goyalb745a2a2021-04-30 13:38:22 -0700427 && (!isShown() || (mEdgeGlowLeft.isFinished() && mEdgeGlowRight.isFinished()))) {
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700428 mIsPageInTransition = false;
429 onPageEndTransition();
Michael Jurkad74c9842011-07-10 12:44:21 -0700430 }
Michael Jurka0142d492010-08-25 17:46:15 -0700431 }
432
Sunny Goyalb745a2a2021-04-30 13:38:22 -0700433 @Override
434 public void onVisibilityAggregated(boolean isVisible) {
435 pageEndTransition();
436 super.onVisibilityAggregated(isVisible);
437 }
438
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700439 protected boolean isPageInTransition() {
440 return mIsPageInTransition;
Adam Cohen26976d92011-03-22 15:33:33 -0700441 }
442
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700443 /**
444 * Called when the page starts moving as part of the scroll. Subclasses can override this
445 * to provide custom behavior during animation.
446 */
447 protected void onPageBeginTransition() {
Patrick Dubroy1262e362010-10-06 15:49:50 -0700448 }
449
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700450 /**
451 * Called when the page ends moving as part of the scroll. Subclasses can override this
452 * to provide custom behavior during animation.
453 */
454 protected void onPageEndTransition() {
vadimt4d93df52019-07-10 17:32:58 -0700455 AccessibilityManagerCompat.sendScrollFinishedEventToTest(getContext());
Tony Wickham619daaf2020-02-07 12:29:06 -0800456 AccessibilityManagerCompat.sendCustomAccessibilityEvent(getPageAt(mCurrentPage),
457 AccessibilityEvent.TYPE_VIEW_FOCUSED, null);
Tony Wickham62117d72020-03-26 16:56:26 -0700458 if (mOnPageTransitionEndCallback != null) {
459 mOnPageTransitionEndCallback.run();
460 mOnPageTransitionEndCallback = null;
461 }
462 }
463
464 /**
465 * Sets a callback to run once when the scrolling finishes. If there is currently
466 * no page in transition, then the callback is called immediately.
467 */
468 public void setOnPageTransitionEndCallback(@Nullable Runnable callback) {
469 if (mIsPageInTransition || callback == null) {
470 mOnPageTransitionEndCallback = callback;
471 } else {
472 callback.run();
473 }
Michael Jurka0142d492010-08-25 17:46:15 -0700474 }
475
Adam Cohen68d73932010-11-15 10:50:58 -0800476 @Override
Michael Jurka0142d492010-08-25 17:46:15 -0700477 public void scrollTo(int x, int y) {
Sunny Goyalc39db732021-04-03 01:20:21 -0700478 x = Utilities.boundToRange(x,
479 mOrientationHandler.getPrimaryValue(mMinScroll, 0), mMaxScroll);
480 y = Utilities.boundToRange(y,
481 mOrientationHandler.getPrimaryValue(0, mMinScroll), mMaxScroll);
Vinit Nayaka406f722019-12-19 11:50:55 -0800482 super.scrollTo(x, y);
Michael Jurka0142d492010-08-25 17:46:15 -0700483 }
484
Adam Cohen53805212013-10-01 10:39:23 -0700485 private void sendScrollAccessibilityEvent() {
Sunny Goyald0030b02017-12-08 15:07:24 -0800486 if (isObservedEventType(getContext(), AccessibilityEvent.TYPE_VIEW_SCROLLED)) {
Vadim Tryshevf4715972015-05-08 17:21:03 -0700487 if (mCurrentPage != getNextPage()) {
488 AccessibilityEvent ev =
489 AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_SCROLLED);
Vadim Tryshev7066c122015-05-21 14:06:35 -0700490 ev.setScrollable(true);
491 ev.setScrollX(getScrollX());
492 ev.setScrollY(getScrollY());
Vinit Nayaka406f722019-12-19 11:50:55 -0800493 mOrientationHandler.setMaxScroll(ev, mMaxScroll);
Vadim Tryshevf4715972015-05-08 17:21:03 -0700494 sendAccessibilityEventUnchecked(ev);
Adam Cohen53805212013-10-01 10:39:23 -0700495 }
Adam Cohen53805212013-10-01 10:39:23 -0700496 }
497 }
498
Vadim Tryshev2c430b32018-04-04 14:45:21 -0700499 protected void announcePageForAccessibility() {
500 if (isAccessibilityEnabled(getContext())) {
501 // Notify the user when the page changes
502 announceForAccessibility(getCurrentPageDescription());
503 }
504 }
505
Winson Chung85425412021-05-10 16:24:14 -0700506 protected boolean computeScrollHelper() {
Winson Chung321e9ee2010-08-09 13:37:56 -0700507 if (mScroller.computeScrollOffset()) {
Winson Chung557d6ed2011-07-08 15:34:52 -0700508 // Don't bother scrolling if the page does not need to be moved
Sunny Goyalc39db732021-04-03 01:20:21 -0700509 int oldPos = mOrientationHandler.getPrimaryScroll(this);
510 int newPos = mScroller.getCurrX();
511 if (oldPos != newPos) {
512 mOrientationHandler.set(this, VIEW_SCROLL_TO, mScroller.getCurrX());
Winson Chung557d6ed2011-07-08 15:34:52 -0700513 }
Winson Chung85425412021-05-10 16:24:14 -0700514
515 if (mAllowOverScroll) {
516 if (newPos < mMinScroll && oldPos >= mMinScroll) {
517 mEdgeGlowLeft.onAbsorb((int) mScroller.getCurrVelocity());
518 mScroller.abortAnimation();
519 } else if (newPos > mMaxScroll && oldPos <= mMaxScroll) {
520 mEdgeGlowRight.onAbsorb((int) mScroller.getCurrVelocity());
521 mScroller.abortAnimation();
Sunny Goyalc39db732021-04-03 01:20:21 -0700522 }
Tony Wickham95cdb3a2016-02-18 14:37:07 -0800523 }
Adam Cohen53805212013-10-01 10:39:23 -0700524
Winson Chung85425412021-05-10 16:24:14 -0700525 // If the scroller has scrolled to the final position and there is no edge effect, then
526 // finish the scroller to skip waiting for additional settling
527 int finalPos = mOrientationHandler.getPrimaryValue(mScroller.getFinalX(),
528 mScroller.getFinalY());
529 if (newPos == finalPos && mEdgeGlowLeft.isFinished() && mEdgeGlowRight.isFinished()) {
530 mScroller.abortAnimation();
531 }
532
533 invalidate();
534 return true;
535 } else if (mNextPage != INVALID_PAGE) {
536 sendScrollAccessibilityEvent();
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700537 int prevPage = mCurrentPage;
Adam Cohen6f127a62014-06-12 14:54:41 -0700538 mCurrentPage = validateNewPage(mNextPage);
Winson Chung86f77532010-08-24 11:08:22 -0700539 mNextPage = INVALID_PAGE;
Hyunyoung Song3f5a11f2017-06-29 16:42:04 -0700540 notifyPageSwitchListener(prevPage);
Winson Chungb44b5242011-06-13 11:32:14 -0700541
Adam Cohen73aa9752010-11-24 16:26:58 -0800542 // We don't want to trigger a page end moving unless the page has settled
543 // and the user has stopped scrolling
Sunny Goyalaad33592018-08-07 17:20:35 -0700544 if (!mIsBeingDragged) {
Sunny Goyal9ccafbf2016-10-26 13:06:08 -0700545 pageEndTransition();
Adam Cohen73aa9752010-11-24 16:26:58 -0800546 }
Winson Chungc27d1bb2011-09-29 12:07:42 -0700547
Vadim Tryshev2c430b32018-04-04 14:45:21 -0700548 if (canAnnouncePageDescription()) {
549 announcePageForAccessibility();
Adam Cohen0ffac432013-07-10 11:19:26 -0700550 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700551 }
Michael Jurka0142d492010-08-25 17:46:15 -0700552 return false;
553 }
554
555 @Override
556 public void computeScroll() {
557 computeScrollHelper();
Winson Chung321e9ee2010-08-09 13:37:56 -0700558 }
559
Sunny Goyalce8809a2018-01-18 14:02:47 -0800560 public int getExpectedHeight() {
561 return getMeasuredHeight();
562 }
563
Adam Cohen410f3cd2013-09-22 12:09:32 -0700564 public int getNormalChildHeight() {
Sunny Goyalce8809a2018-01-18 14:02:47 -0800565 return getExpectedHeight() - getPaddingTop() - getPaddingBottom()
Sunny Goyalac00cba2017-11-13 15:58:01 -0800566 - mInsets.top - mInsets.bottom;
Adam Cohen410f3cd2013-09-22 12:09:32 -0700567 }
568
Sunny Goyalce8809a2018-01-18 14:02:47 -0800569 public int getExpectedWidth() {
570 return getMeasuredWidth();
571 }
572
Sunny Goyalbc683e92017-12-06 10:25:07 -0800573 public int getNormalChildWidth() {
Sunny Goyalce8809a2018-01-18 14:02:47 -0800574 return getExpectedWidth() - getPaddingLeft() - getPaddingRight()
Sunny Goyalbc683e92017-12-06 10:25:07 -0800575 - mInsets.left - mInsets.right;
576 }
577
Winson Chung321e9ee2010-08-09 13:37:56 -0700578 @Override
Sunny Goyal85a7fe02018-02-02 10:09:32 -0800579 public void requestLayout() {
580 mIsLayoutValid = false;
581 super.requestLayout();
582 }
583
584 @Override
585 public void forceLayout() {
586 mIsLayoutValid = false;
587 super.forceLayout();
588 }
589
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100590 private int getPageWidthSize(int widthSize) {
591 return (widthSize - mInsets.left - mInsets.right) / getPanelCount();
592 }
593
Sunny Goyal85a7fe02018-02-02 10:09:32 -0800594 @Override
Winson Chung321e9ee2010-08-09 13:37:56 -0700595 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
Sunny Goyal8e2133b2015-05-06 13:39:07 -0700596 if (getChildCount() == 0) {
Winson Chungf0ea4d32011-06-06 14:27:16 -0700597 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
598 return;
599 }
600
Adam Cohen7d30a372013-07-01 17:03:59 -0700601 // We measure the dimensions of the PagedView to be larger than the pages so that when we
602 // zoom out (and scale down), the view is still contained in the parent
Adam Cohen7d30a372013-07-01 17:03:59 -0700603 int widthMode = MeasureSpec.getMode(widthMeasureSpec);
604 int widthSize = MeasureSpec.getSize(widthMeasureSpec);
605 int heightMode = MeasureSpec.getMode(heightMeasureSpec);
Winson Chung8aad6102012-05-11 16:27:49 -0700606 int heightSize = MeasureSpec.getSize(heightMeasureSpec);
Adam Cohen410f3cd2013-09-22 12:09:32 -0700607
Adam Cohen7d30a372013-07-01 17:03:59 -0700608 if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
609 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
610 return;
Winson Chung321e9ee2010-08-09 13:37:56 -0700611 }
612
Winson Chung8aad6102012-05-11 16:27:49 -0700613 // Return early if we aren't given a proper dimension
614 if (widthSize <= 0 || heightSize <= 0) {
615 super.onMeasure(widthMeasureSpec, heightMeasureSpec);
616 return;
617 }
618
Winson Chung321e9ee2010-08-09 13:37:56 -0700619 // The children are given the same width and height as the workspace
Michael Jurka5f1c5092010-09-03 14:15:02 -0700620 // unless they were set to WRAP_CONTENT
Winson Chung785d2eb2011-04-14 16:08:02 -0700621 if (DEBUG) Log.d(TAG, "PagedView.onMeasure(): " + widthSize + ", " + heightSize);
Michael Jurka5f1c5092010-09-03 14:15:02 -0700622
Sunny Goyalac00cba2017-11-13 15:58:01 -0800623 int myWidthSpec = MeasureSpec.makeMeasureSpec(
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100624 getPageWidthSize(widthSize), MeasureSpec.EXACTLY);
Sunny Goyalac00cba2017-11-13 15:58:01 -0800625 int myHeightSpec = MeasureSpec.makeMeasureSpec(
Sunny Goyal228153d2018-01-04 15:35:22 -0800626 heightSize - mInsets.top - mInsets.bottom, MeasureSpec.EXACTLY);
Adam Cohen96d30a12013-07-16 18:13:21 -0700627
Sunny Goyalac00cba2017-11-13 15:58:01 -0800628 // measureChildren takes accounts for content padding, we only need to care about extra
629 // space due to insets.
630 measureChildren(myWidthSpec, myHeightSpec);
631 setMeasuredDimension(widthSize, heightSize);
Adam Cohen60b07122011-11-14 17:26:06 -0800632 }
633
Sunny Goyalcf25b522015-07-09 00:01:18 -0700634 @SuppressLint("DrawAllocation")
Winson Chung321e9ee2010-08-09 13:37:56 -0700635 @Override
Michael Jurka28750fb2010-09-24 17:43:49 -0700636 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
Sunny Goyal85a7fe02018-02-02 10:09:32 -0800637 mIsLayoutValid = true;
Vadim Trysheveb701c62018-05-14 16:00:15 -0700638 final int childCount = getChildCount();
639 boolean pageScrollChanged = false;
640 if (mPageScrolls == null || childCount != mPageScrolls.length) {
641 mPageScrolls = new int[childCount];
642 pageScrollChanged = true;
643 }
644
645 if (childCount == 0) {
Winson Chungf0ea4d32011-06-06 14:27:16 -0700646 return;
647 }
648
Winson Chung785d2eb2011-04-14 16:08:02 -0700649 if (DEBUG) Log.d(TAG, "PagedView.onLayout()");
Winson Chung321e9ee2010-08-09 13:37:56 -0700650
Vinit Nayaka406f722019-12-19 11:50:55 -0800651 boolean isScrollChanged = getPageScrolls(mPageScrolls, true, SIMPLE_SCROLL_LOGIC);
652 if (isScrollChanged) {
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700653 pageScrollChanged = true;
Winson Chung321e9ee2010-08-09 13:37:56 -0700654 }
Winson Chungc3665fa2011-09-14 17:56:27 -0700655
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700656 final LayoutTransition transition = getLayoutTransition();
657 // If the transition is running defer updating max scroll, as some empty pages could
658 // still be present, and a max scroll change could cause sudden jumps in scroll.
659 if (transition != null && transition.isRunning()) {
660 transition.addTransitionListener(new LayoutTransition.TransitionListener() {
661
662 @Override
663 public void startTransition(LayoutTransition transition, ViewGroup container,
664 View view, int transitionType) { }
665
666 @Override
667 public void endTransition(LayoutTransition transition, ViewGroup container,
668 View view, int transitionType) {
669 // Wait until all transitions are complete.
670 if (!transition.isRunning()) {
671 transition.removeTransitionListener(this);
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700672 updateMinAndMaxScrollX();
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700673 }
674 }
675 });
Adam Cohenf698c6e2013-07-17 18:44:25 -0700676 } else {
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700677 updateMinAndMaxScrollX();
Adam Cohenf698c6e2013-07-17 18:44:25 -0700678 }
679
Sunny Goyalcb037ee2015-07-08 16:41:21 -0700680 if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < childCount) {
681 updateCurrentPageScroll();
682 mFirstLayout = false;
683 }
684
Sunny Goyal85a7fe02018-02-02 10:09:32 -0800685 if (mScroller.isFinished() && pageScrollChanged) {
Sunny Goyalc82c6392018-06-06 15:39:13 -0700686 setCurrentPage(getNextPage());
Adam Cohenf698c6e2013-07-17 18:44:25 -0700687 }
Winson Chunge3193b92010-09-10 11:44:42 -0700688 }
689
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700690 /**
691 * Initializes {@code outPageScrolls} with scroll positions for view at that index. The length
692 * of {@code outPageScrolls} should be same as the the childCount
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700693 */
694 protected boolean getPageScrolls(int[] outPageScrolls, boolean layoutChildren,
695 ComputePageScrollsLogic scrollLogic) {
696 final int childCount = getChildCount();
697
698 final int startIndex = mIsRtl ? childCount - 1 : 0;
699 final int endIndex = mIsRtl ? -1 : childCount;
700 final int delta = mIsRtl ? -1 : 1;
701
Vinit Nayaka406f722019-12-19 11:50:55 -0800702 final int pageCenter = mOrientationHandler.getCenterForPage(this, mInsets);
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700703
Vinit Nayaka406f722019-12-19 11:50:55 -0800704 final int scrollOffsetStart = mOrientationHandler.getScrollOffsetStart(this, mInsets);
705 final int scrollOffsetEnd = mOrientationHandler.getScrollOffsetEnd(this, mInsets);
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700706 boolean pageScrollChanged = false;
707
Vinit Nayaka406f722019-12-19 11:50:55 -0800708 for (int i = startIndex, childStart = scrollOffsetStart; i != endIndex; i += delta) {
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700709 final View child = getPageAt(i);
710 if (scrollLogic.shouldIncludeView(child)) {
Vinit Nayaka406f722019-12-19 11:50:55 -0800711 ChildBounds bounds = mOrientationHandler.getChildBounds(child, childStart,
712 pageCenter, layoutChildren);
713 final int primaryDimension = bounds.primaryDimension;
714 final int childPrimaryEnd = bounds.childPrimaryEnd;
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700715
Alex Chaub5c4d112021-03-29 17:37:53 +0100716 // In case the pages are of different width, align the page to left edge for non-RTL
717 // or right edge for RTL.
718 final int pageScroll =
719 mIsRtl ? childPrimaryEnd - scrollOffsetEnd : childStart - scrollOffsetStart;
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700720 if (outPageScrolls[i] != pageScroll) {
721 pageScrollChanged = true;
722 outPageScrolls[i] = pageScroll;
723 }
Vinit Nayaka406f722019-12-19 11:50:55 -0800724 childStart += primaryDimension + mPageSpacing + getChildGap();
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700725 }
726 }
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100727
728 int panelCount = getPanelCount();
729 if (panelCount > 1) {
730 for (int i = 0; i < childCount; i++) {
731 // In case we have multiple panels, always use left panel's page scroll for all
732 // panels on the screen.
733 int adjustedScroll = outPageScrolls[getLeftmostVisiblePageForIndex(i)];
734 if (outPageScrolls[i] != adjustedScroll) {
735 outPageScrolls[i] = adjustedScroll;
736 pageScrollChanged = true;
737 }
738 }
739 }
Sunny Goyal20a13ff2018-03-13 16:44:00 -0700740 return pageScrollChanged;
741 }
742
Sunny Goyala1fbd842015-05-20 13:40:27 -0700743 protected int getChildGap() {
744 return 0;
745 }
746
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700747 protected void updateMinAndMaxScrollX() {
Vinit Nayaka406f722019-12-19 11:50:55 -0800748 mMinScroll = computeMinScroll();
749 mMaxScroll = computeMaxScroll();
Tony Wickhamf549dab2016-05-16 09:54:06 -0700750 }
751
Vinit Nayaka406f722019-12-19 11:50:55 -0800752 protected int computeMinScroll() {
Tony Wickham66d1c2f2019-04-24 11:32:59 -0700753 return 0;
Tony50876bf2018-09-19 23:09:14 -0400754 }
755
Vinit Nayaka406f722019-12-19 11:50:55 -0800756 protected int computeMaxScroll() {
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700757 int childCount = getChildCount();
758 if (childCount > 0) {
Sunny Goyal70660032015-05-14 00:07:08 -0700759 final int index = mIsRtl ? 0 : childCount - 1;
Tony Wickhamf549dab2016-05-16 09:54:06 -0700760 return getScrollForPage(index);
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700761 } else {
Tony Wickhamf549dab2016-05-16 09:54:06 -0700762 return 0;
Sunny Goyal3e2ff8a2015-04-15 16:31:22 -0700763 }
764 }
765
Adam Cohen3b185e22013-10-29 14:45:58 -0700766 public void setPageSpacing(int pageSpacing) {
767 mPageSpacing = pageSpacing;
768 requestLayout();
769 }
770
Tony50876bf2018-09-19 23:09:14 -0400771 public int getPageSpacing() {
772 return mPageSpacing;
773 }
774
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800775 private void dispatchPageCountChanged() {
776 if (mPageIndicator != null) {
777 mPageIndicator.setMarkersCount(getChildCount());
Winson Chungd2be3812013-07-16 11:11:32 -0700778 }
Adam Cohen2591f6a2011-10-25 14:36:40 -0700779 // This ensures that when children are added, they get the correct transforms / alphas
780 // in accordance with any scroll effects.
Adam Cohen2591f6a2011-10-25 14:36:40 -0700781 invalidate();
782 }
783
Michael Jurka8b805b12012-04-18 14:23:14 -0700784 @Override
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800785 public void onViewAdded(View child) {
Winson Chungc7c51582018-02-23 17:58:36 -0800786 super.onViewAdded(child);
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800787 dispatchPageCountChanged();
788 }
789
790 @Override
791 public void onViewRemoved(View child) {
Winson Chungc7c51582018-02-23 17:58:36 -0800792 super.onViewRemoved(child);
Tonya361c722017-07-04 09:43:06 -0700793 mCurrentPage = validateNewPage(mCurrentPage);
Sunny Goyal0bd7f4f2018-02-01 09:53:35 -0800794 dispatchPageCountChanged();
Winson Chungd2be3812013-07-16 11:11:32 -0700795 }
796
Adam Cohen73894962011-10-31 13:17:17 -0700797 protected int getChildOffset(int index) {
Adam Cohen7d30a372013-07-01 17:03:59 -0700798 if (index < 0 || index > getChildCount() - 1) return 0;
Vinit Nayaka406f722019-12-19 11:50:55 -0800799 View pageAtIndex = getPageAt(index);
800 return mOrientationHandler.getChildStart(pageAtIndex);
Adam Cohen73894962011-10-31 13:17:17 -0700801 }
802
Alex Chau7944ee52021-01-08 19:07:25 +0000803 protected int getChildVisibleSize(int index) {
804 View layout = getPageAt(index);
805 return mOrientationHandler.getMeasuredSize(layout);
806 }
807
Winson Chung321e9ee2010-08-09 13:37:56 -0700808 @Override
809 public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
Adam Cohenae4f1552011-10-20 00:15:42 -0700810 int page = indexToPage(indexOfChild(child));
Winson Chung86f77532010-08-24 11:08:22 -0700811 if (page != mCurrentPage || !mScroller.isFinished()) {
Vadim Trysheveeaa8ee2018-04-11 12:23:42 -0700812 if (immediate) {
813 setCurrentPage(page);
814 } else {
815 snapToPage(page);
816 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700817 return true;
818 }
819 return false;
820 }
821
822 @Override
823 protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
Winson Chung86f77532010-08-24 11:08:22 -0700824 int focusablePage;
825 if (mNextPage != INVALID_PAGE) {
826 focusablePage = mNextPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700827 } else {
Winson Chung86f77532010-08-24 11:08:22 -0700828 focusablePage = mCurrentPage;
Winson Chung321e9ee2010-08-09 13:37:56 -0700829 }
Winson Chung86f77532010-08-24 11:08:22 -0700830 View v = getPageAt(focusablePage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700831 if (v != null) {
Adam Cohen76fc0852011-06-17 13:26:23 -0700832 return v.requestFocus(direction, previouslyFocusedRect);
Winson Chung321e9ee2010-08-09 13:37:56 -0700833 }
834 return false;
835 }
836
837 @Override
838 public boolean dispatchUnhandledMove(View focused, int direction) {
Sunny Goyal0c4e3722015-12-01 13:21:49 -0800839 if (super.dispatchUnhandledMove(focused, direction)) {
840 return true;
841 }
842
843 if (mIsRtl) {
844 if (direction == View.FOCUS_LEFT) {
845 direction = View.FOCUS_RIGHT;
846 } else if (direction == View.FOCUS_RIGHT) {
847 direction = View.FOCUS_LEFT;
848 }
849 }
Winson Chung321e9ee2010-08-09 13:37:56 -0700850 if (direction == View.FOCUS_LEFT) {
Winson Chung86f77532010-08-24 11:08:22 -0700851 if (getCurrentPage() > 0) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100852 int nextPage = validateNewPage(getCurrentPage() - 1);
853 snapToPage(nextPage);
854 getChildAt(nextPage).requestFocus(direction);
Winson Chung321e9ee2010-08-09 13:37:56 -0700855 return true;
856 }
857 } else if (direction == View.FOCUS_RIGHT) {
Winson Chung86f77532010-08-24 11:08:22 -0700858 if (getCurrentPage() < getPageCount() - 1) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100859 int nextPage = validateNewPage(getCurrentPage() + 1);
860 snapToPage(nextPage);
861 getChildAt(nextPage).requestFocus(direction);
Winson Chung321e9ee2010-08-09 13:37:56 -0700862 return true;
863 }
864 }
Sunny Goyal0c4e3722015-12-01 13:21:49 -0800865 return false;
Winson Chung321e9ee2010-08-09 13:37:56 -0700866 }
867
868 @Override
869 public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {
Jon Miranda6a858172016-10-25 16:19:17 -0700870 if (getDescendantFocusability() == FOCUS_BLOCK_DESCENDANTS) {
871 return;
872 }
873
Andras Kloczl359d1ae2021-05-04 22:25:27 +0200874 // Add the current page's views as focusable and the next possible page's too. If the
875 // last focus change action was left then the left neighbour's views will be added, and
876 // if it was right then the right neighbour's views will be added.
877 // Unfortunately mCurrentPage can be outdated if there were multiple control actions in a
878 // short period of time, but mNextPage is up to date because it is always updated by
879 // method snapToPage.
880 int nextPage = getNextPage();
Adam Cohen0ffac432013-07-10 11:19:26 -0700881 // XXX-RTL: This will be fixed in a future CL
Andras Kloczl359d1ae2021-05-04 22:25:27 +0200882 if (nextPage >= 0 && nextPage < getPageCount()) {
883 getPageAt(nextPage).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -0700884 }
885 if (direction == View.FOCUS_LEFT) {
Andras Kloczl359d1ae2021-05-04 22:25:27 +0200886 if (nextPage > 0) {
887 nextPage = validateNewPage(nextPage - 1);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100888 getPageAt(nextPage).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -0700889 }
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100890 } else if (direction == View.FOCUS_RIGHT) {
Andras Kloczl359d1ae2021-05-04 22:25:27 +0200891 if (nextPage < getPageCount() - 1) {
892 nextPage = validateNewPage(nextPage + 1);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100893 getPageAt(nextPage).addFocusables(views, direction, focusableMode);
Winson Chung321e9ee2010-08-09 13:37:56 -0700894 }
895 }
896 }
897
898 /**
899 * If one of our descendant views decides that it could be focused now, only
Winson Chung86f77532010-08-24 11:08:22 -0700900 * pass that along if it's on the current page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700901 *
Winson Chung86f77532010-08-24 11:08:22 -0700902 * This happens when live folders requery, and if they're off page, they
903 * end up calling requestFocus, which pulls it on page.
Winson Chung321e9ee2010-08-09 13:37:56 -0700904 */
905 @Override
906 public void focusableViewAvailable(View focused) {
Winson Chung86f77532010-08-24 11:08:22 -0700907 View current = getPageAt(mCurrentPage);
Winson Chung321e9ee2010-08-09 13:37:56 -0700908 View v = focused;
909 while (true) {
910 if (v == current) {
911 super.focusableViewAvailable(focused);
912 return;
913 }
914 if (v == this) {
915 return;
916 }
917 ViewParent parent = v.getParent();
918 if (parent instanceof View) {
919 v = (View)v.getParent();
920 } else {
921 return;
922 }
923 }
924 }
925
926 /**
927 * {@inheritDoc}
928 */
929 @Override
930 public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {
931 if (disallowIntercept) {
932 // We need to make sure to cancel our long press if
933 // a scrollable widget takes over touch events
Andras Kloczl7a1ca0b2021-04-08 16:08:16 +0200934 cancelCurrentPageLongPress();
Winson Chung321e9ee2010-08-09 13:37:56 -0700935 }
936 super.requestDisallowInterceptTouchEvent(disallowIntercept);
937 }
938
939 @Override
940 public boolean onInterceptTouchEvent(MotionEvent ev) {
941 /*
942 * This method JUST determines whether we want to intercept the motion.
943 * If we return true, onTouchEvent will be called and we do the actual
944 * scrolling there.
945 */
946
Winson Chung45e1d6e2010-11-09 17:19:49 -0800947 // Skip touch handling if there are no pages to swipe
Tony Wickhamb6841ac2019-07-22 12:39:59 -0700948 if (getChildCount() <= 0) return false;
Sunny Goyalc4bb3732019-06-20 11:34:14 -0700949
950 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung45e1d6e2010-11-09 17:19:49 -0800951
Winson Chung321e9ee2010-08-09 13:37:56 -0700952 /*
953 * Shortcut the most recurring case: the user is in the dragging
954 * state and he is moving his finger. We want to intercept this
955 * motion.
956 */
957 final int action = ev.getAction();
Sunny Goyalaad33592018-08-07 17:20:35 -0700958 if ((action == MotionEvent.ACTION_MOVE) && mIsBeingDragged) {
Winson Chung321e9ee2010-08-09 13:37:56 -0700959 return true;
960 }
961
Winson Chung321e9ee2010-08-09 13:37:56 -0700962 switch (action & MotionEvent.ACTION_MASK) {
963 case MotionEvent.ACTION_MOVE: {
964 /*
965 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check
Vinit Nayaka406f722019-12-19 11:50:55 -0800966 * whether the user has moved far enough from their original down touch.
Winson Chung321e9ee2010-08-09 13:37:56 -0700967 */
Michael Jurka1ff706b2010-09-14 17:35:20 -0700968 if (mActivePointerId != INVALID_POINTER) {
969 determineScrollingStart(ev);
Michael Jurka1ff706b2010-09-14 17:35:20 -0700970 }
971 // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN
Vinit Nayaka406f722019-12-19 11:50:55 -0800972 // event. in that case, treat the first occurrence of a move event as a ACTION_DOWN
Michael Jurka1ff706b2010-09-14 17:35:20 -0700973 // i.e. fall through to the next case (don't break)
974 // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events
975 // while it's small- this was causing a crash before we checked for INVALID_POINTER)
Adam Cohen93c97562013-09-26 13:48:01 -0700976 break;
Winson Chung321e9ee2010-08-09 13:37:56 -0700977 }
978
979 case MotionEvent.ACTION_DOWN: {
980 final float x = ev.getX();
981 final float y = ev.getY();
982 // Remember location of down touch
983 mDownMotionX = x;
Adam Cohen7d30a372013-07-01 17:03:59 -0700984 mDownMotionY = y;
Jon Mirandaf52af432020-04-10 17:25:57 -0700985 mDownMotionPrimary = mLastMotion = mOrientationHandler.getPrimaryDirection(ev, 0);
Vinit Nayaka406f722019-12-19 11:50:55 -0800986 mLastMotionRemainder = 0;
987 mTotalMotion = 0;
Winson Chung4941f652020-06-18 15:11:53 -0700988 mAllowEasyFling = false;
Winson Chung321e9ee2010-08-09 13:37:56 -0700989 mActivePointerId = ev.getPointerId(0);
Sunny Goyalc39db732021-04-03 01:20:21 -0700990 updateIsBeingDraggedOnTouchDown(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -0700991 break;
992 }
993
Winson Chung321e9ee2010-08-09 13:37:56 -0700994 case MotionEvent.ACTION_UP:
Jeff Brown1d0867c2010-12-02 18:27:39 -0800995 case MotionEvent.ACTION_CANCEL:
Adam Cohen7d30a372013-07-01 17:03:59 -0700996 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -0700997 break;
998
999 case MotionEvent.ACTION_POINTER_UP:
1000 onSecondaryPointerUp(ev);
Adam Cohen6342bba2011-03-10 11:33:35 -08001001 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001002 break;
1003 }
1004
1005 /*
1006 * The only time we want to intercept motion events is if we are in the
1007 * drag mode.
1008 */
Sunny Goyalaad33592018-08-07 17:20:35 -07001009 return mIsBeingDragged;
Winson Chung321e9ee2010-08-09 13:37:56 -07001010 }
1011
Tony Wickhama0aee212019-09-18 09:24:03 -07001012 /**
1013 * If being flinged and user touches the screen, initiate drag; otherwise don't.
1014 */
Sunny Goyalc39db732021-04-03 01:20:21 -07001015 private void updateIsBeingDraggedOnTouchDown(MotionEvent ev) {
Tony Wickhama0aee212019-09-18 09:24:03 -07001016 // mScroller.isFinished should be false when being flinged.
Sunny Goyalc39db732021-04-03 01:20:21 -07001017 final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX());
Winson Chung4941f652020-06-18 15:11:53 -07001018 final boolean finishedScrolling = (mScroller.isFinished() || xDist < mPageSlop / 3);
Tony Wickhama0aee212019-09-18 09:24:03 -07001019
1020 if (finishedScrolling) {
1021 mIsBeingDragged = false;
1022 if (!mScroller.isFinished() && !mFreeScroll) {
1023 setCurrentPage(getNextPage());
1024 pageEndTransition();
1025 }
Sunny Goyalc39db732021-04-03 01:20:21 -07001026 mIsBeingDragged = !mEdgeGlowLeft.isFinished() || !mEdgeGlowRight.isFinished();
Tony Wickhama0aee212019-09-18 09:24:03 -07001027 } else {
1028 mIsBeingDragged = true;
1029 }
Sunny Goyalc39db732021-04-03 01:20:21 -07001030
1031 // Catch the edge effect if it is active.
1032 float displacement = mOrientationHandler.getSecondaryValue(ev.getX(), ev.getY())
1033 / mOrientationHandler.getSecondaryValue(getWidth(), getHeight());
1034 if (!mEdgeGlowLeft.isFinished()) {
1035 mEdgeGlowLeft.onPullDistance(0f, 1f - displacement);
1036 }
1037 if (!mEdgeGlowRight.isFinished()) {
1038 mEdgeGlowRight.onPullDistance(0f, displacement);
1039 }
Tony Wickhama0aee212019-09-18 09:24:03 -07001040 }
1041
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001042 public boolean isHandlingTouch() {
Sunny Goyalaad33592018-08-07 17:20:35 -07001043 return mIsBeingDragged;
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001044 }
1045
Adam Cohenf8d28232011-02-01 21:47:00 -08001046 protected void determineScrollingStart(MotionEvent ev) {
1047 determineScrollingStart(ev, 1.0f);
1048 }
1049
Winson Chung321e9ee2010-08-09 13:37:56 -07001050 /*
1051 * Determines if we should change the touch state to start scrolling after the
1052 * user moves their touch point too far.
1053 */
Adam Cohenf8d28232011-02-01 21:47:00 -08001054 protected void determineScrollingStart(MotionEvent ev, float touchSlopScale) {
Adam Cohen7d30a372013-07-01 17:03:59 -07001055 // Disallow scrolling if we don't have a valid pointer index
Winson Chung321e9ee2010-08-09 13:37:56 -07001056 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
Adam Cohen7d30a372013-07-01 17:03:59 -07001057 if (pointerIndex == -1) return;
1058
Vinit Nayaka406f722019-12-19 11:50:55 -08001059 final float primaryDirection = mOrientationHandler.getPrimaryDirection(ev, pointerIndex);
1060 final int diff = (int) Math.abs(primaryDirection - mLastMotion);
Adam Cohenf8d28232011-02-01 21:47:00 -08001061 final int touchSlop = Math.round(touchSlopScale * mTouchSlop);
Winson Chung4941f652020-06-18 15:11:53 -07001062 boolean moved = diff > touchSlop || ev.getAction() == ACTION_MOVE_ALLOW_EASY_FLING;
Winson Chung321e9ee2010-08-09 13:37:56 -07001063
Vinit Nayaka406f722019-12-19 11:50:55 -08001064 if (moved) {
Sunny Goyal5a1f53b2015-05-27 10:24:24 -07001065 // Scroll if the user moved far enough along the X axis
Sunny Goyalaad33592018-08-07 17:20:35 -07001066 mIsBeingDragged = true;
Vinit Nayaka406f722019-12-19 11:50:55 -08001067 mTotalMotion += Math.abs(mLastMotion - primaryDirection);
1068 mLastMotion = primaryDirection;
1069 mLastMotionRemainder = 0;
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001070 pageBeginTransition();
Tony Wickhamdadb3042016-02-24 11:07:00 -08001071 // Stop listening for things like pinches.
1072 requestDisallowInterceptTouchEvent(true);
Adam Cohenf8d28232011-02-01 21:47:00 -08001073 }
1074 }
1075
1076 protected void cancelCurrentPageLongPress() {
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001077 // Try canceling the long press. It could also have been scheduled
1078 // by a distant descendant, so use the mAllowLongPress flag to block
1079 // everything
Sunny Goyal59969372021-05-06 12:11:44 -07001080 forEachVisiblePage(View::cancelLongPress);
Winson Chung321e9ee2010-08-09 13:37:56 -07001081 }
1082
Adam Cohenb5ba0972011-09-07 18:02:31 -07001083 protected float getScrollProgress(int screenCenter, View v, int page) {
Sunny Goyal228153d2018-01-04 15:35:22 -08001084 final int halfScreenSize = getMeasuredWidth() / 2;
Adam Cohenb5ba0972011-09-07 18:02:31 -07001085
Adam Cohenedb40762013-07-18 16:45:45 -07001086 int delta = screenCenter - (getScrollForPage(page) + halfScreenSize);
Adam Cohen3b185e22013-10-29 14:45:58 -07001087 int count = getChildCount();
1088
1089 final int totalDistance;
1090
1091 int adjacentPage = page + 1;
Sunny Goyal70660032015-05-14 00:07:08 -07001092 if ((delta < 0 && !mIsRtl) || (delta > 0 && mIsRtl)) {
Adam Cohen3b185e22013-10-29 14:45:58 -07001093 adjacentPage = page - 1;
1094 }
1095
1096 if (adjacentPage < 0 || adjacentPage > count - 1) {
1097 totalDistance = v.getMeasuredWidth() + mPageSpacing;
1098 } else {
1099 totalDistance = Math.abs(getScrollForPage(adjacentPage) - getScrollForPage(page));
1100 }
Adam Cohenb5ba0972011-09-07 18:02:31 -07001101
1102 float scrollProgress = delta / (totalDistance * 1.0f);
Sunny Goyal8e2133b2015-05-06 13:39:07 -07001103 scrollProgress = Math.min(scrollProgress, MAX_SCROLL_PROGRESS);
1104 scrollProgress = Math.max(scrollProgress, - MAX_SCROLL_PROGRESS);
Adam Cohenb5ba0972011-09-07 18:02:31 -07001105 return scrollProgress;
1106 }
1107
Adam Cohenedb40762013-07-18 16:45:45 -07001108 public int getScrollForPage(int index) {
Adam Cohen1f1f45d2013-10-02 09:40:18 -07001109 if (mPageScrolls == null || index >= mPageScrolls.length || index < 0) {
Adam Cohenedb40762013-07-18 16:45:45 -07001110 return 0;
1111 } else {
1112 return mPageScrolls[index];
1113 }
1114 }
1115
Adam Cohen564a2e72013-10-09 14:47:32 -07001116 // While layout transitions are occurring, a child's position may stray from its baseline
1117 // position. This method returns the magnitude of this stray at any given time.
1118 public int getLayoutTransitionOffsetForPage(int index) {
1119 if (mPageScrolls == null || index >= mPageScrolls.length || index < 0) {
1120 return 0;
1121 } else {
1122 View child = getChildAt(index);
Adam Cohen3b185e22013-10-29 14:45:58 -07001123
Sunny Goyal228153d2018-01-04 15:35:22 -08001124 int scrollOffset = mIsRtl ? getPaddingRight() : getPaddingLeft();
1125 int baselineX = mPageScrolls[index] + scrollOffset;
Adam Cohen564a2e72013-10-09 14:47:32 -07001126 return (int) (child.getX() - baselineX);
1127 }
1128 }
1129
Tony Wickham023f4042019-01-29 10:52:31 -08001130 public void setEnableFreeScroll(boolean freeScroll) {
Winson Chung0e449002019-04-26 11:09:58 -07001131 if (mFreeScroll == freeScroll) {
1132 return;
1133 }
1134
Tony Wickham8f7ead32016-04-07 18:46:44 -07001135 boolean wasFreeScroll = mFreeScroll;
Adam Cohenf358a4b2013-07-23 16:47:31 -07001136 mFreeScroll = freeScroll;
1137
Adam Cohenf9618852013-11-08 06:45:03 -08001138 if (mFreeScroll) {
Sunny Goyal4d519f22017-10-24 10:32:40 -07001139 setCurrentPage(getNextPage());
Tony Wickham8f7ead32016-04-07 18:46:44 -07001140 } else if (wasFreeScroll) {
Tony Wickhamaf33f2c2019-10-04 12:55:22 -07001141 if (getScrollForPage(getNextPage()) != getScrollX()) {
1142 snapToPage(getNextPage());
1143 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07001144 }
Adam Cohenf358a4b2013-07-23 16:47:31 -07001145 }
1146
Sunny Goyal2f0ec852015-03-26 13:38:27 -07001147 protected void setEnableOverscroll(boolean enable) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001148 mAllowOverScroll = enable;
1149 }
1150
Alex Chau822acf42021-06-03 11:35:05 +01001151 protected float getSignificantMoveThreshold() {
1152 return SIGNIFICANT_MOVE_THRESHOLD;
1153 }
1154
Winson Chung321e9ee2010-08-09 13:37:56 -07001155 @Override
1156 public boolean onTouchEvent(MotionEvent ev) {
Winson Chung45e1d6e2010-11-09 17:19:49 -08001157 // Skip touch handling if there are no pages to swipe
Tony Wickhamb6841ac2019-07-22 12:39:59 -07001158 if (getChildCount() <= 0) return false;
Winson Chung45e1d6e2010-11-09 17:19:49 -08001159
Michael Jurkab8f06722010-10-10 15:58:46 -07001160 acquireVelocityTrackerAndAddMovement(ev);
Winson Chung321e9ee2010-08-09 13:37:56 -07001161
1162 final int action = ev.getAction();
1163
1164 switch (action & MotionEvent.ACTION_MASK) {
1165 case MotionEvent.ACTION_DOWN:
Sunny Goyalc39db732021-04-03 01:20:21 -07001166 updateIsBeingDraggedOnTouchDown(ev);
Tony Wickhama0aee212019-09-18 09:24:03 -07001167
Winson Chung321e9ee2010-08-09 13:37:56 -07001168 /*
1169 * If being flinged and user touches, stop the fling. isFinished
1170 * will be false if being flinged.
1171 */
1172 if (!mScroller.isFinished()) {
Adam Cohen8bdbaab2013-10-29 15:25:02 -07001173 abortScrollerAnimation(false);
Winson Chung321e9ee2010-08-09 13:37:56 -07001174 }
1175
1176 // Remember where the motion event started
Vinit Nayaka406f722019-12-19 11:50:55 -08001177 mDownMotionX = ev.getX();
Sunny Goyal7c7be8c2018-03-07 19:58:07 -08001178 mDownMotionY = ev.getY();
Vinit Nayaka406f722019-12-19 11:50:55 -08001179 mDownMotionPrimary = mLastMotion = mOrientationHandler.getPrimaryDirection(ev, 0);
1180 mLastMotionRemainder = 0;
1181 mTotalMotion = 0;
Winson Chung4941f652020-06-18 15:11:53 -07001182 mAllowEasyFling = false;
Winson Chung321e9ee2010-08-09 13:37:56 -07001183 mActivePointerId = ev.getPointerId(0);
Sunny Goyalaad33592018-08-07 17:20:35 -07001184 if (mIsBeingDragged) {
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001185 pageBeginTransition();
Michael Jurka0142d492010-08-25 17:46:15 -07001186 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001187 break;
1188
Winson Chung4941f652020-06-18 15:11:53 -07001189 case ACTION_MOVE_ALLOW_EASY_FLING:
1190 // Start scrolling immediately
1191 determineScrollingStart(ev);
1192 mAllowEasyFling = true;
1193 break;
1194
1195 case MotionEvent.ACTION_MOVE:
1196 if (mIsBeingDragged) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001197 // Scroll to follow the motion event
1198 final int pointerIndex = ev.findPointerIndex(mActivePointerId);
Adam Cohen7d30a372013-07-01 17:03:59 -07001199
1200 if (pointerIndex == -1) return true;
Sunny Goyalc39db732021-04-03 01:20:21 -07001201 float oldScroll = mOrientationHandler.getPrimaryScroll(this);
1202 float dx = ev.getX(pointerIndex);
1203 float dy = ev.getY(pointerIndex);
Adam Cohen7d30a372013-07-01 17:03:59 -07001204
Sunny Goyalc39db732021-04-03 01:20:21 -07001205 float direction = mOrientationHandler.getPrimaryValue(dx, dy);
Vinit Nayaka406f722019-12-19 11:50:55 -08001206 float delta = mLastMotion + mLastMotionRemainder - direction;
Sunny Goyalc39db732021-04-03 01:20:21 -07001207
1208 int width = getWidth();
1209 int height = getHeight();
1210 int size = mOrientationHandler.getPrimaryValue(width, height);
1211
1212 final float displacement = mOrientationHandler.getSecondaryValue(dx, dy)
1213 / mOrientationHandler.getSecondaryValue(width, height);
Vinit Nayaka406f722019-12-19 11:50:55 -08001214 mTotalMotion += Math.abs(delta);
Adam Cohenaefd4e12011-02-14 16:39:38 -08001215
Sunny Goyalc39db732021-04-03 01:20:21 -07001216 if (mAllowOverScroll) {
1217 float consumed = 0;
1218 if (delta < 0 && mEdgeGlowRight.getDistance() != 0f) {
1219 consumed = size * mEdgeGlowRight.onPullDistance(delta / size, displacement);
1220 } else if (delta > 0 && mEdgeGlowLeft.getDistance() != 0f) {
1221 consumed = -size * mEdgeGlowLeft.onPullDistance(
1222 -delta / size, 1 - displacement);
1223 }
1224 delta -= consumed;
1225 }
Alex Chau822acf42021-06-03 11:35:05 +01001226 delta /= mOrientationHandler.getPrimaryScale(this);
Sunny Goyalc39db732021-04-03 01:20:21 -07001227
Winson Chungc0844aa2011-02-02 15:25:58 -08001228 // Only scroll and update mLastMotionX if we have moved some discrete amount. We
1229 // keep the remainder because we are actually testing if we've moved from the last
1230 // scrolled position (which is discrete).
Sunny Goyalc39db732021-04-03 01:20:21 -07001231 mLastMotion = direction;
1232 int movedDelta = (int) delta;
1233 mLastMotionRemainder = delta - movedDelta;
Vinit Nayaka406f722019-12-19 11:50:55 -08001234
Sunny Goyalc39db732021-04-03 01:20:21 -07001235 if (delta != 0) {
1236 mOrientationHandler.set(this, VIEW_SCROLL_BY, movedDelta);
1237
1238 if (mAllowOverScroll) {
1239 final float pulledToX = oldScroll + delta;
1240
1241 if (pulledToX < mMinScroll) {
1242 mEdgeGlowLeft.onPullDistance(-delta / size, 1.f - displacement);
1243 if (!mEdgeGlowRight.isFinished()) {
1244 mEdgeGlowRight.onRelease();
1245 }
1246 } else if (pulledToX > mMaxScroll) {
1247 mEdgeGlowRight.onPullDistance(delta / size, displacement);
1248 if (!mEdgeGlowLeft.isFinished()) {
1249 mEdgeGlowLeft.onRelease();
1250 }
1251 }
1252
1253 if (!mEdgeGlowLeft.isFinished() || !mEdgeGlowRight.isFinished()) {
1254 postInvalidateOnAnimation();
1255 }
1256 }
1257
Winson Chung321e9ee2010-08-09 13:37:56 -07001258 } else {
1259 awakenScrollBars();
1260 }
Adam Cohen564976a2010-10-13 18:52:07 -07001261 } else {
Winson Chung321e9ee2010-08-09 13:37:56 -07001262 determineScrollingStart(ev);
1263 }
1264 break;
1265
1266 case MotionEvent.ACTION_UP:
Sunny Goyalaad33592018-08-07 17:20:35 -07001267 if (mIsBeingDragged) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001268 final int activePointerId = mActivePointerId;
1269 final int pointerIndex = ev.findPointerIndex(activePointerId);
Vinit Nayak93bf1fe2020-05-26 17:22:13 -07001270 if (pointerIndex == -1) return true;
1271
Vinit Nayaka406f722019-12-19 11:50:55 -08001272 final float primaryDirection = mOrientationHandler.getPrimaryDirection(ev,
1273 pointerIndex);
Sunny Goyal4bb8b062019-02-19 16:37:38 -08001274 final VelocityTracker velocityTracker = mVelocityTracker;
1275 velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
Adam Cohenaefd4e12011-02-14 16:39:38 -08001276
Vinit Nayaka406f722019-12-19 11:50:55 -08001277 int velocity = (int) mOrientationHandler.getPrimaryVelocity(velocityTracker,
1278 mActivePointerId);
Alex Chau822acf42021-06-03 11:35:05 +01001279 float delta = primaryDirection - mDownMotionPrimary;
1280 delta /= mOrientationHandler.getPrimaryScale(this);
Vinit Nayaka406f722019-12-19 11:50:55 -08001281 int pageOrientedSize = mOrientationHandler.getMeasuredSize(getPageAt(mCurrentPage));
1282
Alex Chau822acf42021-06-03 11:35:05 +01001283 boolean isSignificantMove = Math.abs(delta)
1284 > pageOrientedSize * getSignificantMoveThreshold();
Vinit Nayaka406f722019-12-19 11:50:55 -08001285
1286 mTotalMotion += Math.abs(mLastMotion + mLastMotionRemainder - primaryDirection);
Winson Chung4941f652020-06-18 15:11:53 -07001287 boolean passedSlop = mAllowEasyFling || mTotalMotion > mPageSlop;
1288 boolean isFling = passedSlop && shouldFlingForVelocity(velocity);
Vinit Nayaka406f722019-12-19 11:50:55 -08001289 boolean isDeltaLeft = mIsRtl ? delta > 0 : delta < 0;
1290 boolean isVelocityLeft = mIsRtl ? velocity > 0 : velocity < 0;
Winson Chung4941f652020-06-18 15:11:53 -07001291 if (DEBUG_FAILED_QUICKSWITCH && !isFling && mAllowEasyFling) {
1292 Log.d("Quickswitch", "isFling=false vel=" + velocity
1293 + " threshold=" + mEasyFlingThresholdVelocity);
1294 }
Adam Cohen00481b32011-11-18 12:03:48 -08001295
Adam Cohenf358a4b2013-07-23 16:47:31 -07001296 if (!mFreeScroll) {
1297 // In the case that the page is moved far to one direction and then is flung
1298 // in the opposite direction, we use a threshold to determine whether we should
1299 // just return to the starting page, or if we should skip one further.
1300 boolean returnToOriginalPage = false;
Vinit Nayaka406f722019-12-19 11:50:55 -08001301 if (Math.abs(delta) > pageOrientedSize * RETURN_TO_ORIGINAL_PAGE_THRESHOLD &&
1302 Math.signum(velocity) != Math.signum(delta) && isFling) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001303 returnToOriginalPage = true;
1304 }
Adam Cohenaefd4e12011-02-14 16:39:38 -08001305
Adam Cohenf358a4b2013-07-23 16:47:31 -07001306 int finalPage;
1307 // We give flings precedence over large moves, which is why we short-circuit our
1308 // test for a large move if a fling has been registered. That is, a large
1309 // move to the left and fling to the right will register as a fling to the right.
Sunny Goyalb7b01352018-08-09 12:31:20 -07001310
Vinit Nayaka406f722019-12-19 11:50:55 -08001311 if (((isSignificantMove && !isDeltaLeft && !isFling) ||
1312 (isFling && !isVelocityLeft)) && mCurrentPage > 0) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001313 finalPage = returnToOriginalPage
1314 ? mCurrentPage : mCurrentPage - getPanelCount();
Vinit Nayaka406f722019-12-19 11:50:55 -08001315 snapToPageWithVelocity(finalPage, velocity);
1316 } else if (((isSignificantMove && isDeltaLeft && !isFling) ||
1317 (isFling && isVelocityLeft)) &&
Adam Cohenf358a4b2013-07-23 16:47:31 -07001318 mCurrentPage < getChildCount() - 1) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001319 finalPage = returnToOriginalPage
1320 ? mCurrentPage : mCurrentPage + getPanelCount();
Vinit Nayaka406f722019-12-19 11:50:55 -08001321 snapToPageWithVelocity(finalPage, velocity);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001322 } else {
1323 snapToDestination();
Adam Cohenf358a4b2013-07-23 16:47:31 -07001324 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001325 } else {
Santiago Etchebehere260b4cb2018-06-15 16:42:19 -07001326 if (!mScroller.isFinished()) {
1327 abortScrollerAnimation(true);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001328 }
Santiago Etchebehere260b4cb2018-06-15 16:42:19 -07001329
Vinit Nayaka406f722019-12-19 11:50:55 -08001330 int initialScroll = mOrientationHandler.getPrimaryScroll(this);
1331 int maxScroll = mMaxScroll;
1332 int minScroll = mMinScroll;
Santiago Etchebehere260b4cb2018-06-15 16:42:19 -07001333
Vinit Nayaka406f722019-12-19 11:50:55 -08001334 if (((initialScroll >= maxScroll) && (isVelocityLeft || !isFling)) ||
1335 ((initialScroll <= minScroll) && (!isVelocityLeft || !isFling))) {
Sunny Goyalc39db732021-04-03 01:20:21 -07001336 mScroller.springBack(initialScroll, 0, minScroll, maxScroll, 0, 0);
Alex Chaub794ea62021-02-03 18:00:30 +00001337 mNextPage = getDestinationPage();
Sunny Goyalb7b01352018-08-09 12:31:20 -07001338 } else {
Sunny Goyalc39db732021-04-03 01:20:21 -07001339 int velocity1 = -velocity;
1340 // Continue a scroll or fling in progress
1341 mScroller.fling(initialScroll, 0, velocity1, 0, minScroll, maxScroll, 0, 0,
1342 Math.round(getWidth() * 0.5f * OVERSCROLL_DAMP_FACTOR), 0);
Santiago Etchebehere260b4cb2018-06-15 16:42:19 -07001343
Sunny Goyalc39db732021-04-03 01:20:21 -07001344 int finalPos = mScroller.getFinalX();
Alex Chaub794ea62021-02-03 18:00:30 +00001345 mNextPage = getDestinationPage(finalPos);
Sunny Goyalc39db732021-04-03 01:20:21 -07001346 onNotSnappingToPageInFreeScroll();
Santiago Etchebehere260b4cb2018-06-15 16:42:19 -07001347 }
1348 invalidate();
Winson Chung321e9ee2010-08-09 13:37:56 -07001349 }
Winson Chung321e9ee2010-08-09 13:37:56 -07001350 }
Adam Cohen7d30a372013-07-01 17:03:59 -07001351
Sunny Goyalc39db732021-04-03 01:20:21 -07001352 mEdgeGlowLeft.onRelease();
1353 mEdgeGlowRight.onRelease();
Adam Cohen7d30a372013-07-01 17:03:59 -07001354 // End any intermediate reordering states
1355 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001356 break;
1357
1358 case MotionEvent.ACTION_CANCEL:
Sunny Goyalaad33592018-08-07 17:20:35 -07001359 if (mIsBeingDragged) {
Michael Jurkab8f06722010-10-10 15:58:46 -07001360 snapToDestination();
1361 }
Sunny Goyalc39db732021-04-03 01:20:21 -07001362 mEdgeGlowLeft.onRelease();
1363 mEdgeGlowRight.onRelease();
Adam Cohen7d30a372013-07-01 17:03:59 -07001364 resetTouchState();
Winson Chung321e9ee2010-08-09 13:37:56 -07001365 break;
1366
1367 case MotionEvent.ACTION_POINTER_UP:
1368 onSecondaryPointerUp(ev);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001369 releaseVelocityTracker();
Winson Chung321e9ee2010-08-09 13:37:56 -07001370 break;
1371 }
1372
1373 return true;
1374 }
1375
Sunny Goyalc39db732021-04-03 01:20:21 -07001376 protected void onNotSnappingToPageInFreeScroll() { }
Alex Chaub794ea62021-02-03 18:00:30 +00001377
Vinit Nayaka406f722019-12-19 11:50:55 -08001378 protected boolean shouldFlingForVelocity(int velocity) {
Winson Chung4941f652020-06-18 15:11:53 -07001379 float threshold = mAllowEasyFling ? mEasyFlingThresholdVelocity : mFlingThresholdVelocity;
1380 return Math.abs(velocity) > threshold;
Sunny Goyal65d9ceb2017-05-08 09:17:42 -07001381 }
1382
Adam Cohen7d30a372013-07-01 17:03:59 -07001383 private void resetTouchState() {
1384 releaseVelocityTracker();
Sunny Goyalaad33592018-08-07 17:20:35 -07001385 mIsBeingDragged = false;
Adam Cohen7d30a372013-07-01 17:03:59 -07001386 mActivePointerId = INVALID_POINTER;
Adam Cohen7d30a372013-07-01 17:03:59 -07001387 }
1388
Winson Chung185d7162011-02-28 13:47:29 -08001389 @Override
1390 public boolean onGenericMotionEvent(MotionEvent event) {
1391 if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) {
1392 switch (event.getAction()) {
1393 case MotionEvent.ACTION_SCROLL: {
1394 // Handle mouse (or ext. device) by shifting the page depending on the scroll
1395 final float vscroll;
1396 final float hscroll;
1397 if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) {
1398 vscroll = 0;
1399 hscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL);
1400 } else {
1401 vscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL);
1402 hscroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL);
1403 }
Sunny Goyal8b37c572020-03-31 12:12:14 -07001404 if (!canScroll(Math.abs(vscroll), Math.abs(hscroll))) {
1405 return false;
Samuel Fufa59cba192019-08-22 18:31:34 -07001406 }
Winson Chung185d7162011-02-28 13:47:29 -08001407 if (hscroll != 0 || vscroll != 0) {
Sunny Goyal70660032015-05-14 00:07:08 -07001408 boolean isForwardScroll = mIsRtl ? (hscroll < 0 || vscroll < 0)
Adam Cohen0ffac432013-07-10 11:19:26 -07001409 : (hscroll > 0 || vscroll > 0);
1410 if (isForwardScroll) {
Winson Chung185d7162011-02-28 13:47:29 -08001411 scrollRight();
1412 } else {
1413 scrollLeft();
1414 }
1415 return true;
1416 }
1417 }
1418 }
1419 }
1420 return super.onGenericMotionEvent(event);
1421 }
1422
Sunny Goyal8b37c572020-03-31 12:12:14 -07001423 /**
1424 * Returns true if the paged view can scroll for the provided vertical and horizontal
1425 * scroll values
1426 */
1427 protected boolean canScroll(float absVScroll, float absHScroll) {
1428 ActivityContext ac = ActivityContext.lookupContext(getContext());
1429 return (ac == null || AbstractFloatingView.getTopOpenView(ac) == null);
Samuel Fufa59cba192019-08-22 18:31:34 -07001430 }
1431
Michael Jurkab8f06722010-10-10 15:58:46 -07001432 private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) {
1433 if (mVelocityTracker == null) {
1434 mVelocityTracker = VelocityTracker.obtain();
1435 }
1436 mVelocityTracker.addMovement(ev);
1437 }
1438
1439 private void releaseVelocityTracker() {
1440 if (mVelocityTracker != null) {
Adam Cohenf358a4b2013-07-23 16:47:31 -07001441 mVelocityTracker.clear();
Michael Jurkab8f06722010-10-10 15:58:46 -07001442 mVelocityTracker.recycle();
1443 mVelocityTracker = null;
1444 }
1445 }
1446
Winson Chung321e9ee2010-08-09 13:37:56 -07001447 private void onSecondaryPointerUp(MotionEvent ev) {
Winson Chung4941f652020-06-18 15:11:53 -07001448 final int pointerIndex = ev.getActionIndex();
Winson Chung321e9ee2010-08-09 13:37:56 -07001449 final int pointerId = ev.getPointerId(pointerIndex);
1450 if (pointerId == mActivePointerId) {
1451 // This was our active pointer going up. Choose a new
1452 // active pointer and adjust accordingly.
1453 // TODO: Make this decision more intelligent.
1454 final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
Vinit Nayaka406f722019-12-19 11:50:55 -08001455 mLastMotion = mDownMotionPrimary = mOrientationHandler.getPrimaryDirection(ev,
1456 newPointerIndex);
1457 mLastMotionRemainder = 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001458 mActivePointerId = ev.getPointerId(newPointerIndex);
1459 if (mVelocityTracker != null) {
1460 mVelocityTracker.clear();
1461 }
1462 }
Jeff Brown1d0867c2010-12-02 18:27:39 -08001463 }
1464
Winson Chung321e9ee2010-08-09 13:37:56 -07001465 @Override
1466 public void requestChildFocus(View child, View focused) {
1467 super.requestChildFocus(child, focused);
Andras Kloczl359d1ae2021-05-04 22:25:27 +02001468
1469 // In case the device is controlled by a controller, mCurrentPage isn't updated properly
1470 // which results in incorrect navigation
1471 int nextPage = getNextPage();
1472 if (nextPage != mCurrentPage) {
1473 setCurrentPage(nextPage);
1474 }
1475
Adam Cohenae4f1552011-10-20 00:15:42 -07001476 int page = indexToPage(indexOfChild(child));
Winson Chung97d85d22011-04-13 11:27:36 -07001477 if (page >= 0 && page != getCurrentPage() && !isInTouchMode()) {
Winson Chung86f77532010-08-24 11:08:22 -07001478 snapToPage(page);
Winson Chung321e9ee2010-08-09 13:37:56 -07001479 }
1480 }
1481
Alex Chaub794ea62021-02-03 18:00:30 +00001482 public int getDestinationPage() {
1483 return getDestinationPage(mOrientationHandler.getPrimaryScroll(this));
1484 }
1485
Alex Chaudedbc8a2021-03-17 16:53:26 +00001486 protected int getDestinationPage(int primaryScroll) {
1487 return getPageNearestToCenterOfScreen(primaryScroll);
Alex Chaub794ea62021-02-03 18:00:30 +00001488 }
1489
Sunny Goyal228153d2018-01-04 15:35:22 -08001490 public int getPageNearestToCenterOfScreen() {
Vinit Nayaka406f722019-12-19 11:50:55 -08001491 return getPageNearestToCenterOfScreen(mOrientationHandler.getPrimaryScroll(this));
Tony Wickham8f7ead32016-04-07 18:46:44 -07001492 }
1493
Alex Chaudedbc8a2021-03-17 16:53:26 +00001494 private int getPageNearestToCenterOfScreen(int primaryScroll) {
1495 int screenCenter = getScreenCenter(primaryScroll);
Adam Cohen22f823d2011-09-01 17:22:18 -07001496 int minDistanceFromScreenCenter = Integer.MAX_VALUE;
Winson Chung321e9ee2010-08-09 13:37:56 -07001497 int minDistanceFromScreenCenterIndex = -1;
Winson Chung321e9ee2010-08-09 13:37:56 -07001498 final int childCount = getChildCount();
1499 for (int i = 0; i < childCount; ++i) {
Tony Wickham7383d4e2020-07-07 19:25:25 -07001500 int distanceFromScreenCenter = Math.abs(
1501 getDisplacementFromScreenCenter(i, screenCenter));
Winson Chung321e9ee2010-08-09 13:37:56 -07001502 if (distanceFromScreenCenter < minDistanceFromScreenCenter) {
1503 minDistanceFromScreenCenter = distanceFromScreenCenter;
1504 minDistanceFromScreenCenterIndex = i;
1505 }
1506 }
Adam Cohend19d3ca2010-09-15 14:43:42 -07001507 return minDistanceFromScreenCenterIndex;
1508 }
1509
Tony Wickham7383d4e2020-07-07 19:25:25 -07001510 private int getDisplacementFromScreenCenter(int childIndex, int screenCenter) {
Alex Chaudedbc8a2021-03-17 16:53:26 +00001511 int childSize = Math.round(getChildVisibleSize(childIndex));
Tony Wickham7383d4e2020-07-07 19:25:25 -07001512 int halfChildSize = (childSize / 2);
1513 int childCenter = getChildOffset(childIndex) + halfChildSize;
1514 return childCenter - screenCenter;
1515 }
1516
1517 protected int getDisplacementFromScreenCenter(int childIndex) {
Alex Chaudedbc8a2021-03-17 16:53:26 +00001518 int primaryScroll = mOrientationHandler.getPrimaryScroll(this);
1519 int screenCenter = getScreenCenter(primaryScroll);
Tony Wickham7383d4e2020-07-07 19:25:25 -07001520 return getDisplacementFromScreenCenter(childIndex, screenCenter);
1521 }
1522
Alex Chaudedbc8a2021-03-17 16:53:26 +00001523 private int getScreenCenter(int primaryScroll) {
1524 float primaryScale = mOrientationHandler.getPrimaryScale(this);
1525 float primaryPivot = mOrientationHandler.getPrimaryValue(getPivotX(), getPivotY());
1526 int pageOrientationSize = mOrientationHandler.getMeasuredSize(this);
1527 return Math.round(primaryScroll + (pageOrientationSize / 2f - primaryPivot) / primaryScale
1528 + primaryPivot);
1529 }
1530
Adam Cohend19d3ca2010-09-15 14:43:42 -07001531 protected void snapToDestination() {
Sunny Goyalc39db732021-04-03 01:20:21 -07001532 snapToPage(getDestinationPage(), PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07001533 }
1534
Adam Cohene0f66b52010-11-23 15:06:07 -08001535 // We want the duration of the page snap animation to be influenced by the distance that
1536 // the screen has to travel, however, we don't want this duration to be effected in a
1537 // purely linear fashion. Instead, we use this method to moderate the effect that the distance
1538 // of travel has on the overall snap duration.
Sunny Goyal4d113a52015-05-27 10:05:28 -07001539 private float distanceInfluenceForSnapDuration(float f) {
Adam Cohene0f66b52010-11-23 15:06:07 -08001540 f -= 0.5f; // center the values about 0.
1541 f *= 0.3f * Math.PI / 2.0f;
1542 return (float) Math.sin(f);
1543 }
1544
Winson Chung05a31ed2018-02-08 17:08:43 -08001545 protected boolean snapToPageWithVelocity(int whichPage, int velocity) {
Adam Cohen6f127a62014-06-12 14:54:41 -07001546 whichPage = validateNewPage(whichPage);
Vinit Nayaka406f722019-12-19 11:50:55 -08001547 int halfScreenSize = mOrientationHandler.getMeasuredSize(this) / 2;
Adam Cohene0f66b52010-11-23 15:06:07 -08001548
Vinit Nayaka406f722019-12-19 11:50:55 -08001549 final int newLoc = getScrollForPage(whichPage);
Sunny Goyalc39db732021-04-03 01:20:21 -07001550 int delta = newLoc - mOrientationHandler.getPrimaryScroll(this);
Adam Cohene0f66b52010-11-23 15:06:07 -08001551 int duration = 0;
1552
Sunny Goyal4d113a52015-05-27 10:05:28 -07001553 if (Math.abs(velocity) < mMinFlingVelocity) {
Adam Cohene0f66b52010-11-23 15:06:07 -08001554 // If the velocity is low enough, then treat this more as an automatic page advance
1555 // as opposed to an apparent physical response to flinging
Winson Chung05a31ed2018-02-08 17:08:43 -08001556 return snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
Adam Cohene0f66b52010-11-23 15:06:07 -08001557 }
1558
1559 // Here we compute a "distance" that will be used in the computation of the overall
1560 // snap duration. This is a function of the actual distance that needs to be traveled;
1561 // we keep this value close to half screen size in order to reduce the variance in snap
1562 // duration as a function of the distance the page needs to travel.
Michael Jurka20b7ca92011-06-07 20:09:16 -07001563 float distanceRatio = Math.min(1f, 1.0f * Math.abs(delta) / (2 * halfScreenSize));
Adam Cohene0f66b52010-11-23 15:06:07 -08001564 float distance = halfScreenSize + halfScreenSize *
1565 distanceInfluenceForSnapDuration(distanceRatio);
1566
1567 velocity = Math.abs(velocity);
Adam Cohen265b9a62011-12-07 14:37:18 -08001568 velocity = Math.max(mMinSnapVelocity, velocity);
Adam Cohene0f66b52010-11-23 15:06:07 -08001569
1570 // we want the page's snap velocity to approximately match the velocity at which the
1571 // user flings, so we scale the duration by a value near to the derivative of the scroll
Michael Jurka20b7ca92011-06-07 20:09:16 -07001572 // interpolator at zero, ie. 5. We use 4 to make it a little slower.
1573 duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
Adam Cohene0f66b52010-11-23 15:06:07 -08001574
Sunny Goyalc39db732021-04-03 01:20:21 -07001575 return snapToPage(whichPage, delta, duration);
Michael Jurka0142d492010-08-25 17:46:15 -07001576 }
1577
Winson Chung05a31ed2018-02-08 17:08:43 -08001578 public boolean snapToPage(int whichPage) {
1579 return snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION);
Winson Chung321e9ee2010-08-09 13:37:56 -07001580 }
1581
Winson Chung05a31ed2018-02-08 17:08:43 -08001582 public boolean snapToPageImmediately(int whichPage) {
Sunny Goyalc39db732021-04-03 01:20:21 -07001583 return snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION, true);
Adam Cohen7d30a372013-07-01 17:03:59 -07001584 }
1585
Winson Chung05a31ed2018-02-08 17:08:43 -08001586 public boolean snapToPage(int whichPage, int duration) {
Sunny Goyalc39db732021-04-03 01:20:21 -07001587 return snapToPage(whichPage, duration, false);
Adam Cohen7d30a372013-07-01 17:03:59 -07001588 }
1589
Sunny Goyalc39db732021-04-03 01:20:21 -07001590 protected boolean snapToPage(int whichPage, int duration, boolean immediate) {
Adam Cohen6f127a62014-06-12 14:54:41 -07001591 whichPage = validateNewPage(whichPage);
Winson Chung321e9ee2010-08-09 13:37:56 -07001592
Vinit Nayaka406f722019-12-19 11:50:55 -08001593 int newLoc = getScrollForPage(whichPage);
Sunny Goyalc39db732021-04-03 01:20:21 -07001594 final int delta = newLoc - mOrientationHandler.getPrimaryScroll(this);
1595 return snapToPage(whichPage, delta, duration, immediate);
Michael Jurka0142d492010-08-25 17:46:15 -07001596 }
1597
Winson Chung05a31ed2018-02-08 17:08:43 -08001598 protected boolean snapToPage(int whichPage, int delta, int duration) {
Sunny Goyalc39db732021-04-03 01:20:21 -07001599 return snapToPage(whichPage, delta, duration, false);
Adam Cohen7d30a372013-07-01 17:03:59 -07001600 }
Michael Jurka0142d492010-08-25 17:46:15 -07001601
Sunny Goyalc39db732021-04-03 01:20:21 -07001602 protected boolean snapToPage(int whichPage, int delta, int duration, boolean immediate) {
Sunny Goyal9bb8ffb2018-05-24 17:11:16 -07001603 if (mFirstLayout) {
1604 setCurrentPage(whichPage);
1605 return false;
1606 }
Tony Wickhamd58c2d52018-05-04 12:10:55 -07001607
Zak Cohen3eeb41d2020-02-14 14:15:13 -08001608 if (FeatureFlags.IS_STUDIO_BUILD) {
Tony Wickhamcb3f8702018-08-27 17:36:03 -07001609 duration *= Settings.Global.getFloat(getContext().getContentResolver(),
1610 Settings.Global.WINDOW_ANIMATION_SCALE, 1);
Tony Wickhamd58c2d52018-05-04 12:10:55 -07001611 }
1612
Adam Cohen6f127a62014-06-12 14:54:41 -07001613 whichPage = validateNewPage(whichPage);
1614
Adam Cohen7d30a372013-07-01 17:03:59 -07001615 mNextPage = whichPage;
Michael Jurka0142d492010-08-25 17:46:15 -07001616
Winson Chung321e9ee2010-08-09 13:37:56 -07001617 awakenScrollBars(duration);
Adam Cohen7d30a372013-07-01 17:03:59 -07001618 if (immediate) {
1619 duration = 0;
1620 } else if (duration == 0) {
Winson Chung321e9ee2010-08-09 13:37:56 -07001621 duration = Math.abs(delta);
1622 }
1623
Sunny Goyal9ccafbf2016-10-26 13:06:08 -07001624 if (duration != 0) {
1625 pageBeginTransition();
1626 }
1627
Adam Cohenf358a4b2013-07-23 16:47:31 -07001628 if (!mScroller.isFinished()) {
Adam Cohenf9618852013-11-08 06:45:03 -08001629 abortScrollerAnimation(false);
Adam Cohenf358a4b2013-07-23 16:47:31 -07001630 }
Adam Cohenf9618852013-11-08 06:45:03 -08001631
Sunny Goyalc39db732021-04-03 01:20:21 -07001632 mScroller.startScroll(mOrientationHandler.getPrimaryScroll(this), 0, delta, 0, duration);
Adam Cohen674531f2013-12-13 15:07:14 -08001633 updatePageIndicator();
Adam Cohen7d30a372013-07-01 17:03:59 -07001634
1635 // Trigger a compute() to finish switching pages if necessary
1636 if (immediate) {
1637 computeScroll();
Sunny Goyal76dbf6f2017-01-03 14:55:47 -08001638 pageEndTransition();
Adam Cohen7d30a372013-07-01 17:03:59 -07001639 }
1640
Winson Chung321e9ee2010-08-09 13:37:56 -07001641 invalidate();
Winson Chung05a31ed2018-02-08 17:08:43 -08001642 return Math.abs(delta) > 0;
Winson Chung321e9ee2010-08-09 13:37:56 -07001643 }
1644
Vadim Tryshev98913d02018-05-18 18:41:34 -07001645 public boolean scrollLeft() {
1646 if (getNextPage() > 0) {
1647 snapToPage(getNextPage() - 1);
1648 return true;
1649 }
Sunny Goyalc39db732021-04-03 01:20:21 -07001650 return mAllowOverScroll;
Winson Chung321e9ee2010-08-09 13:37:56 -07001651 }
1652
Vadim Tryshev98913d02018-05-18 18:41:34 -07001653 public boolean scrollRight() {
1654 if (getNextPage() < getChildCount() - 1) {
1655 snapToPage(getNextPage() + 1);
1656 return true;
1657 }
Sunny Goyalc39db732021-04-03 01:20:21 -07001658 return mAllowOverScroll;
Winson Chung321e9ee2010-08-09 13:37:56 -07001659 }
1660
Vadim Trysheve6bbefb2018-04-03 13:38:06 -07001661 @Override
1662 public CharSequence getAccessibilityClassName() {
1663 // Some accessibility services have special logic for ScrollView. Since we provide same
1664 // accessibility info as ScrollView, inform the service to handle use the same way.
1665 return ScrollView.class.getName();
1666 }
1667
Vadim Tryshev0fc07132018-05-04 12:08:54 -07001668 protected boolean isPageOrderFlipped() {
1669 return false;
1670 }
1671
Winson Chung6a0f57d2011-06-29 20:10:49 -07001672 /* Accessibility */
Sunny Goyalcf25b522015-07-09 00:01:18 -07001673 @SuppressWarnings("deprecation")
Winson Chung6a0f57d2011-06-29 20:10:49 -07001674 @Override
1675 public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) {
1676 super.onInitializeAccessibilityNodeInfo(info);
Vadim Tryshev0fc07132018-05-04 12:08:54 -07001677 final boolean pagesFlipped = isPageOrderFlipped();
Pinyao Tingaf6daa22019-09-18 22:18:03 +00001678 int offset = (mAllowOverScroll ? 0 : 1);
1679 info.setScrollable(getPageCount() > offset);
1680 if (getCurrentPage() < getPageCount() - offset) {
yingleiw02cc8482019-08-02 16:14:27 -07001681 info.addAction(pagesFlipped ?
1682 AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_BACKWARD
1683 : AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_FORWARD);
1684 info.addAction(mIsRtl ?
1685 AccessibilityNodeInfo.AccessibilityAction.ACTION_PAGE_LEFT
1686 : AccessibilityNodeInfo.AccessibilityAction.ACTION_PAGE_RIGHT);
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001687 }
Pinyao Tingaf6daa22019-09-18 22:18:03 +00001688 if (getCurrentPage() >= offset) {
yingleiw02cc8482019-08-02 16:14:27 -07001689 info.addAction(pagesFlipped ?
1690 AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_FORWARD
1691 : AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_BACKWARD);
1692 info.addAction(mIsRtl ?
1693 AccessibilityNodeInfo.AccessibilityAction.ACTION_PAGE_RIGHT
1694 : AccessibilityNodeInfo.AccessibilityAction.ACTION_PAGE_LEFT);
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001695 }
Vadim Tryshev7af0d442015-05-15 08:48:11 -07001696 // Accessibility-wise, PagedView doesn't support long click, so disabling it.
1697 // Besides disabling the accessibility long-click, this also prevents this view from getting
1698 // accessibility focus.
1699 info.setLongClickable(false);
Sunny Goyala52ecb02016-12-16 15:04:51 -08001700 info.removeAction(AccessibilityNodeInfo.AccessibilityAction.ACTION_LONG_CLICK);
Winson Chung6a0f57d2011-06-29 20:10:49 -07001701 }
1702
1703 @Override
Alan Viverette254139a2013-10-08 13:13:46 -07001704 public void sendAccessibilityEvent(int eventType) {
1705 // Don't let the view send real scroll events.
1706 if (eventType != AccessibilityEvent.TYPE_VIEW_SCROLLED) {
1707 super.sendAccessibilityEvent(eventType);
1708 }
1709 }
1710
1711 @Override
Winson Chung6a0f57d2011-06-29 20:10:49 -07001712 public void onInitializeAccessibilityEvent(AccessibilityEvent event) {
1713 super.onInitializeAccessibilityEvent(event);
Pinyao Tingaf6daa22019-09-18 22:18:03 +00001714 event.setScrollable(mAllowOverScroll || getPageCount() > 1);
Winson Chung6a0f57d2011-06-29 20:10:49 -07001715 }
1716
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001717 @Override
1718 public boolean performAccessibilityAction(int action, Bundle arguments) {
1719 if (super.performAccessibilityAction(action, arguments)) {
1720 return true;
1721 }
Vadim Tryshev0fc07132018-05-04 12:08:54 -07001722 final boolean pagesFlipped = isPageOrderFlipped();
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001723 switch (action) {
1724 case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: {
Vadim Tryshev98913d02018-05-18 18:41:34 -07001725 if (pagesFlipped ? scrollLeft() : scrollRight()) {
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001726 return true;
1727 }
1728 } break;
1729 case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: {
Vadim Tryshev98913d02018-05-18 18:41:34 -07001730 if (pagesFlipped ? scrollRight() : scrollLeft()) {
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001731 return true;
1732 }
yingleiw02cc8482019-08-02 16:14:27 -07001733 } break;
1734 case android.R.id.accessibilityActionPageRight: {
1735 if (!mIsRtl) {
1736 return scrollRight();
1737 } else {
1738 return scrollLeft();
1739 }
Vadim Tryshev0fc07132018-05-04 12:08:54 -07001740 }
yingleiw02cc8482019-08-02 16:14:27 -07001741 case android.R.id.accessibilityActionPageLeft: {
1742 if (!mIsRtl) {
1743 return scrollLeft();
1744 } else {
1745 return scrollRight();
1746 }
1747 }
Svetoslav Ganov08055f62012-05-15 11:06:36 -07001748 }
1749 return false;
1750 }
1751
Vadim Tryshev2c430b32018-04-04 14:45:21 -07001752 protected boolean canAnnouncePageDescription() {
1753 return true;
1754 }
1755
Adam Cohen0ffac432013-07-10 11:19:26 -07001756 protected String getCurrentPageDescription() {
Sunny Goyalf4f89ef2015-09-02 15:06:12 -07001757 return getContext().getString(R.string.default_scroll_format,
Adam Cohen0ffac432013-07-10 11:19:26 -07001758 getNextPage() + 1, getChildCount());
1759 }
1760
Tony Mak2e564402018-02-27 17:19:34 +00001761 protected float getDownMotionX() {
1762 return mDownMotionX;
1763 }
1764
1765 protected float getDownMotionY() {
1766 return mDownMotionY;
1767 }
1768
Sunny Goyal20a13ff2018-03-13 16:44:00 -07001769 protected interface ComputePageScrollsLogic {
1770
1771 boolean shouldIncludeView(View view);
1772 }
Vadim Tryshev528b9e02018-05-24 18:22:03 -07001773
1774 public int[] getVisibleChildrenRange() {
1775 float visibleLeft = 0;
1776 float visibleRight = visibleLeft + getMeasuredWidth();
1777 float scaleX = getScaleX();
1778 if (scaleX < 1 && scaleX > 0) {
1779 float mid = getMeasuredWidth() / 2;
1780 visibleLeft = mid - ((mid - visibleLeft) / scaleX);
1781 visibleRight = mid + ((visibleRight - mid) / scaleX);
1782 }
1783
1784 int leftChild = -1;
1785 int rightChild = -1;
1786 final int childCount = getChildCount();
1787 for (int i = 0; i < childCount; i++) {
1788 final View child = getPageAt(i);
1789
1790 float left = child.getLeft() + child.getTranslationX() - getScrollX();
1791 if (left <= visibleRight && (left + child.getMeasuredWidth()) >= visibleLeft) {
1792 if (leftChild == -1) {
1793 leftChild = i;
1794 }
1795 rightChild = i;
1796 }
1797 }
1798 mTmpIntPair[0] = leftChild;
1799 mTmpIntPair[1] = rightChild;
1800 return mTmpIntPair;
1801 }
Sunny Goyalc39db732021-04-03 01:20:21 -07001802
1803 @Override
1804 public void draw(Canvas canvas) {
1805 super.draw(canvas);
1806 drawEdgeEffect(canvas);
Sunny Goyal05b59c02021-04-29 13:55:40 -07001807 pageEndTransition();
Sunny Goyalc39db732021-04-03 01:20:21 -07001808 }
1809
1810 protected void drawEdgeEffect(Canvas canvas) {
1811 if (mAllowOverScroll && (!mEdgeGlowRight.isFinished() || !mEdgeGlowLeft.isFinished())) {
1812 final int width = getWidth();
1813 final int height = getHeight();
1814 if (!mEdgeGlowLeft.isFinished()) {
1815 final int restoreCount = canvas.save();
1816 canvas.rotate(-90);
1817 canvas.translate(-height, Math.min(mMinScroll, getScrollX()));
1818 mEdgeGlowLeft.setSize(height, width);
1819 if (mEdgeGlowLeft.draw(canvas)) {
1820 postInvalidateOnAnimation();
1821 }
1822 canvas.restoreToCount(restoreCount);
1823 }
1824 if (!mEdgeGlowRight.isFinished()) {
1825 final int restoreCount = canvas.save();
1826 canvas.rotate(90, width, 0);
1827 canvas.translate(width, -(Math.max(mMaxScroll, getScrollX())));
1828
1829 mEdgeGlowRight.setSize(height, width);
1830 if (mEdgeGlowRight.draw(canvas)) {
1831 postInvalidateOnAnimation();
1832 }
1833 canvas.restoreToCount(restoreCount);
1834 }
1835 }
1836 }
Adam Cohen5084cba2013-09-03 12:01:16 -07001837}