1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 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 17 package com.android.launcher2; 18 19 import android.animation.Animator; 20 import android.animation.AnimatorListenerAdapter; 21 import android.animation.ValueAnimator; 22 import android.content.Context; 23 import android.content.res.TypedArray; 24 import android.graphics.Canvas; 25 import android.graphics.Rect; 26 import android.os.Bundle; 27 import android.os.Parcel; 28 import android.os.Parcelable; 29 import android.util.AttributeSet; 30 import android.util.Log; 31 import android.view.InputDevice; 32 import android.view.KeyEvent; 33 import android.view.MotionEvent; 34 import android.view.VelocityTracker; 35 import android.view.View; 36 import android.view.ViewConfiguration; 37 import android.view.ViewGroup; 38 import android.view.ViewParent; 39 import android.view.accessibility.AccessibilityEvent; 40 import android.view.accessibility.AccessibilityManager; 41 import android.view.accessibility.AccessibilityNodeInfo; 42 import android.view.animation.Interpolator; 43 import android.widget.Scroller; 44 45 import com.android.launcher.R; 46 47 import java.util.ArrayList; 48 49 /** 50 * An abstraction of the original Workspace which supports browsing through a 51 * sequential list of "pages" 52 */ 53 public abstract class PagedView extends ViewGroup implements ViewGroup.OnHierarchyChangeListener { 54 private static final String TAG = "PagedView"; 55 private static final boolean DEBUG = false; 56 protected static final int INVALID_PAGE = -1; 57 58 // the min drag distance for a fling to register, to prevent random page shifts 59 private static final int MIN_LENGTH_FOR_FLING = 25; 60 61 protected static final int PAGE_SNAP_ANIMATION_DURATION = 550; 62 protected static final int MAX_PAGE_SNAP_DURATION = 750; 63 protected static final int SLOW_PAGE_SNAP_ANIMATION_DURATION = 950; 64 protected static final float NANOTIME_DIV = 1000000000.0f; 65 66 private static final float OVERSCROLL_ACCELERATE_FACTOR = 2; 67 private static final float OVERSCROLL_DAMP_FACTOR = 0.14f; 68 69 private static final float RETURN_TO_ORIGINAL_PAGE_THRESHOLD = 0.33f; 70 // The page is moved more than halfway, automatically move to the next page on touch up. 71 private static final float SIGNIFICANT_MOVE_THRESHOLD = 0.4f; 72 73 // The following constants need to be scaled based on density. The scaled versions will be 74 // assigned to the corresponding member variables below. 75 private static final int FLING_THRESHOLD_VELOCITY = 500; 76 private static final int MIN_SNAP_VELOCITY = 1500; 77 private static final int MIN_FLING_VELOCITY = 250; 78 79 static final int AUTOMATIC_PAGE_SPACING = -1; 80 81 protected int mFlingThresholdVelocity; 82 protected int mMinFlingVelocity; 83 protected int mMinSnapVelocity; 84 85 protected float mDensity; 86 protected float mSmoothingTime; 87 protected float mTouchX; 88 89 protected boolean mFirstLayout = true; 90 91 protected int mCurrentPage; 92 protected int mNextPage = INVALID_PAGE; 93 protected int mMaxScrollX; 94 protected Scroller mScroller; 95 private VelocityTracker mVelocityTracker; 96 97 private float mDownMotionX; 98 protected float mLastMotionX; 99 protected float mLastMotionXRemainder; 100 protected float mLastMotionY; 101 protected float mTotalMotionX; 102 private int mLastScreenCenter = -1; 103 private int[] mChildOffsets; 104 private int[] mChildRelativeOffsets; 105 private int[] mChildOffsetsWithLayoutScale; 106 107 protected final static int TOUCH_STATE_REST = 0; 108 protected final static int TOUCH_STATE_SCROLLING = 1; 109 protected final static int TOUCH_STATE_PREV_PAGE = 2; 110 protected final static int TOUCH_STATE_NEXT_PAGE = 3; 111 protected final static float ALPHA_QUANTIZE_LEVEL = 0.0001f; 112 113 protected int mTouchState = TOUCH_STATE_REST; 114 protected boolean mForceScreenScrolled = false; 115 116 protected OnLongClickListener mLongClickListener; 117 118 protected boolean mAllowLongPress = true; 119 120 protected int mTouchSlop; 121 private int mPagingTouchSlop; 122 private int mMaximumVelocity; 123 private int mMinimumWidth; 124 protected int mPageSpacing; 125 protected int mPageLayoutPaddingTop; 126 protected int mPageLayoutPaddingBottom; 127 protected int mPageLayoutPaddingLeft; 128 protected int mPageLayoutPaddingRight; 129 protected int mPageLayoutWidthGap; 130 protected int mPageLayoutHeightGap; 131 protected int mCellCountX = 0; 132 protected int mCellCountY = 0; 133 protected boolean mCenterPagesVertically; 134 protected boolean mAllowOverScroll = true; 135 protected int mUnboundedScrollX; 136 protected int[] mTempVisiblePagesRange = new int[2]; 137 protected boolean mForceDrawAllChildrenNextFrame; 138 139 // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. Otherwise 140 // it is equal to the scaled overscroll position. We use a separate value so as to prevent 141 // the screens from continuing to translate beyond the normal bounds. 142 protected int mOverScrollX; 143 144 // parameter that adjusts the layout to be optimized for pages with that scale factor 145 protected float mLayoutScale = 1.0f; 146 147 protected static final int INVALID_POINTER = -1; 148 149 protected int mActivePointerId = INVALID_POINTER; 150 151 private PageSwitchListener mPageSwitchListener; 152 153 protected ArrayList<Boolean> mDirtyPageContent; 154 155 // If true, syncPages and syncPageItems will be called to refresh pages 156 protected boolean mContentIsRefreshable = true; 157 158 // If true, modify alpha of neighboring pages as user scrolls left/right 159 protected boolean mFadeInAdjacentScreens = true; 160 161 // It true, use a different slop parameter (pagingTouchSlop = 2 * touchSlop) for deciding 162 // to switch to a new page 163 protected boolean mUsePagingTouchSlop = true; 164 165 // If true, the subclass should directly update scrollX itself in its computeScroll method 166 // (SmoothPagedView does this) 167 protected boolean mDeferScrollUpdate = false; 168 169 protected boolean mIsPageMoving = false; 170 171 // All syncs and layout passes are deferred until data is ready. 172 protected boolean mIsDataReady = false; 173 174 // Scrolling indicator 175 private ValueAnimator mScrollIndicatorAnimator; 176 private View mScrollIndicator; 177 private int mScrollIndicatorPaddingLeft; 178 private int mScrollIndicatorPaddingRight; 179 private boolean mHasScrollIndicator = true; 180 private boolean mShouldShowScrollIndicator = false; 181 private boolean mShouldShowScrollIndicatorImmediately = false; 182 protected static final int sScrollIndicatorFadeInDuration = 150; 183 protected static final int sScrollIndicatorFadeOutDuration = 650; 184 protected static final int sScrollIndicatorFlashDuration = 650; 185 private boolean mScrollingPaused = false; 186 187 // If set, will defer loading associated pages until the scrolling settles 188 private boolean mDeferLoadAssociatedPagesUntilScrollCompletes; 189 190 public interface PageSwitchListener { 191 void onPageSwitch(View newPage, int newPageIndex); 192 } 193 194 public PagedView(Context context) { 195 this(context, null); 196 } 197 198 public PagedView(Context context, AttributeSet attrs) { 199 this(context, attrs, 0); 200 } 201 202 public PagedView(Context context, AttributeSet attrs, int defStyle) { 203 super(context, attrs, defStyle); 204 205 TypedArray a = context.obtainStyledAttributes(attrs, 206 R.styleable.PagedView, defStyle, 0); 207 setPageSpacing(a.getDimensionPixelSize(R.styleable.PagedView_pageSpacing, 0)); 208 mPageLayoutPaddingTop = a.getDimensionPixelSize( 209 R.styleable.PagedView_pageLayoutPaddingTop, 0); 210 mPageLayoutPaddingBottom = a.getDimensionPixelSize( 211 R.styleable.PagedView_pageLayoutPaddingBottom, 0); 212 mPageLayoutPaddingLeft = a.getDimensionPixelSize( 213 R.styleable.PagedView_pageLayoutPaddingLeft, 0); 214 mPageLayoutPaddingRight = a.getDimensionPixelSize( 215 R.styleable.PagedView_pageLayoutPaddingRight, 0); 216 mPageLayoutWidthGap = a.getDimensionPixelSize( 217 R.styleable.PagedView_pageLayoutWidthGap, 0); 218 mPageLayoutHeightGap = a.getDimensionPixelSize( 219 R.styleable.PagedView_pageLayoutHeightGap, 0); 220 mScrollIndicatorPaddingLeft = 221 a.getDimensionPixelSize(R.styleable.PagedView_scrollIndicatorPaddingLeft, 0); 222 mScrollIndicatorPaddingRight = 223 a.getDimensionPixelSize(R.styleable.PagedView_scrollIndicatorPaddingRight, 0); 224 a.recycle(); 225 226 setHapticFeedbackEnabled(false); 227 init(); 228 } 229 230 /** 231 * Initializes various states for this workspace. 232 */ 233 protected void init() { 234 mDirtyPageContent = new ArrayList<Boolean>(); 235 mDirtyPageContent.ensureCapacity(32); 236 mScroller = new Scroller(getContext(), new ScrollInterpolator()); 237 mCurrentPage = 0; 238 mCenterPagesVertically = true; 239 240 final ViewConfiguration configuration = ViewConfiguration.get(getContext()); 241 mTouchSlop = configuration.getScaledTouchSlop(); 242 mPagingTouchSlop = configuration.getScaledPagingTouchSlop(); 243 mMaximumVelocity = configuration.getScaledMaximumFlingVelocity(); 244 mDensity = getResources().getDisplayMetrics().density; 245 246 mFlingThresholdVelocity = (int) (FLING_THRESHOLD_VELOCITY * mDensity); 247 mMinFlingVelocity = (int) (MIN_FLING_VELOCITY * mDensity); 248 mMinSnapVelocity = (int) (MIN_SNAP_VELOCITY * mDensity); 249 setOnHierarchyChangeListener(this); 250 } 251 252 public void setPageSwitchListener(PageSwitchListener pageSwitchListener) { 253 mPageSwitchListener = pageSwitchListener; 254 if (mPageSwitchListener != null) { 255 mPageSwitchListener.onPageSwitch(getPageAt(mCurrentPage), mCurrentPage); 256 } 257 } 258 259 /** 260 * Called by subclasses to mark that data is ready, and that we can begin loading and laying 261 * out pages. 262 */ 263 protected void setDataIsReady() { 264 mIsDataReady = true; 265 } 266 protected boolean isDataReady() { 267 return mIsDataReady; 268 } 269 270 /** 271 * Returns the index of the currently displayed page. 272 * 273 * @return The index of the currently displayed page. 274 */ 275 int getCurrentPage() { 276 return mCurrentPage; 277 } 278 int getNextPage() { 279 return (mNextPage != INVALID_PAGE) ? mNextPage : mCurrentPage; 280 } 281 282 int getPageCount() { 283 return getChildCount(); 284 } 285 286 View getPageAt(int index) { 287 return getChildAt(index); 288 } 289 290 protected int indexToPage(int index) { 291 return index; 292 } 293 294 /** 295 * Updates the scroll of the current page immediately to its final scroll position. We use this 296 * in CustomizePagedView to allow tabs to share the same PagedView while resetting the scroll of 297 * the previous tab page. 298 */ 299 protected void updateCurrentPageScroll() { 300 int offset = getChildOffset(mCurrentPage); 301 int relOffset = getRelativeChildOffset(mCurrentPage); 302 int newX = offset - relOffset; 303 scrollTo(newX, 0); 304 mScroller.setFinalX(newX); 305 mScroller.forceFinished(true); 306 } 307 308 /** 309 * Called during AllApps/Home transitions to avoid unnecessary work. When that other animation 310 * ends, {@link #resumeScrolling()} should be called, along with 311 * {@link #updateCurrentPageScroll()} to correctly set the final state and re-enable scrolling. 312 */ 313 void pauseScrolling() { 314 mScroller.forceFinished(true); 315 cancelScrollingIndicatorAnimations(); 316 mScrollingPaused = true; 317 } 318 319 /** 320 * Enables scrolling again. 321 * @see #pauseScrolling() 322 */ 323 void resumeScrolling() { 324 mScrollingPaused = false; 325 } 326 /** 327 * Sets the current page. 328 */ 329 void setCurrentPage(int currentPage) { 330 if (!mScroller.isFinished()) { 331 mScroller.abortAnimation(); 332 } 333 // don't introduce any checks like mCurrentPage == currentPage here-- if we change the 334 // the default 335 if (getChildCount() == 0) { 336 return; 337 } 338 339 340 mCurrentPage = Math.max(0, Math.min(currentPage, getPageCount() - 1)); 341 updateCurrentPageScroll(); 342 updateScrollingIndicator(); 343 notifyPageSwitchListener(); 344 invalidate(); 345 } 346 347 protected void notifyPageSwitchListener() { 348 if (mPageSwitchListener != null) { 349 mPageSwitchListener.onPageSwitch(getPageAt(mCurrentPage), mCurrentPage); 350 } 351 } 352 353 protected void pageBeginMoving() { 354 if (!mIsPageMoving) { 355 mIsPageMoving = true; 356 onPageBeginMoving(); 357 } 358 } 359 360 protected void pageEndMoving() { 361 if (mIsPageMoving) { 362 mIsPageMoving = false; 363 onPageEndMoving(); 364 } 365 } 366 367 protected boolean isPageMoving() { 368 return mIsPageMoving; 369 } 370 371 // a method that subclasses can override to add behavior 372 protected void onPageBeginMoving() { 373 } 374 375 // a method that subclasses can override to add behavior 376 protected void onPageEndMoving() { 377 } 378 379 /** 380 * Registers the specified listener on each page contained in this workspace. 381 * 382 * @param l The listener used to respond to long clicks. 383 */ 384 @Override 385 public void setOnLongClickListener(OnLongClickListener l) { 386 mLongClickListener = l; 387 final int count = getPageCount(); 388 for (int i = 0; i < count; i++) { 389 getPageAt(i).setOnLongClickListener(l); 390 } 391 } 392 393 @Override 394 public void scrollBy(int x, int y) { 395 scrollTo(mUnboundedScrollX + x, getScrollY() + y); 396 } 397 398 @Override 399 public void scrollTo(int x, int y) { 400 mUnboundedScrollX = x; 401 402 if (x < 0) { 403 super.scrollTo(0, y); 404 if (mAllowOverScroll) { 405 overScroll(x); 406 } 407 } else if (x > mMaxScrollX) { 408 super.scrollTo(mMaxScrollX, y); 409 if (mAllowOverScroll) { 410 overScroll(x - mMaxScrollX); 411 } 412 } else { 413 mOverScrollX = x; 414 super.scrollTo(x, y); 415 } 416 417 mTouchX = x; 418 mSmoothingTime = System.nanoTime() / NANOTIME_DIV; 419 } 420 421 // we moved this functionality to a helper function so SmoothPagedView can reuse it 422 protected boolean computeScrollHelper() { 423 if (mScroller.computeScrollOffset()) { 424 // Don't bother scrolling if the page does not need to be moved 425 if (getScrollX() != mScroller.getCurrX() 426 || getScrollY() != mScroller.getCurrY() 427 || mOverScrollX != mScroller.getCurrX()) { 428 scrollTo(mScroller.getCurrX(), mScroller.getCurrY()); 429 } 430 invalidate(); 431 return true; 432 } else if (mNextPage != INVALID_PAGE) { 433 mCurrentPage = Math.max(0, Math.min(mNextPage, getPageCount() - 1)); 434 mNextPage = INVALID_PAGE; 435 notifyPageSwitchListener(); 436 437 // Load the associated pages if necessary 438 if (mDeferLoadAssociatedPagesUntilScrollCompletes) { 439 loadAssociatedPages(mCurrentPage); 440 mDeferLoadAssociatedPagesUntilScrollCompletes = false; 441 } 442 443 // We don't want to trigger a page end moving unless the page has settled 444 // and the user has stopped scrolling 445 if (mTouchState == TOUCH_STATE_REST) { 446 pageEndMoving(); 447 } 448 449 // Notify the user when the page changes 450 AccessibilityManager accessibilityManager = (AccessibilityManager) 451 getContext().getSystemService(Context.ACCESSIBILITY_SERVICE); 452 if (accessibilityManager.isEnabled()) { 453 AccessibilityEvent ev = 454 AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_SCROLLED); 455 ev.getText().add(getCurrentPageDescription()); 456 sendAccessibilityEventUnchecked(ev); 457 } 458 return true; 459 } 460 return false; 461 } 462 463 @Override 464 public void computeScroll() { 465 computeScrollHelper(); 466 } 467 468 @Override 469 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 470 if (!mIsDataReady) { 471 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 472 return; 473 } 474 475 final int widthMode = MeasureSpec.getMode(widthMeasureSpec); 476 final int widthSize = MeasureSpec.getSize(widthMeasureSpec); 477 final int heightMode = MeasureSpec.getMode(heightMeasureSpec); 478 int heightSize = MeasureSpec.getSize(heightMeasureSpec); 479 if (widthMode != MeasureSpec.EXACTLY) { 480 throw new IllegalStateException("Workspace can only be used in EXACTLY mode."); 481 } 482 483 // Return early if we aren't given a proper dimension 484 if (widthSize <= 0 || heightSize <= 0) { 485 super.onMeasure(widthMeasureSpec, heightMeasureSpec); 486 return; 487 } 488 489 /* Allow the height to be set as WRAP_CONTENT. This allows the particular case 490 * of the All apps view on XLarge displays to not take up more space then it needs. Width 491 * is still not allowed to be set as WRAP_CONTENT since many parts of the code expect 492 * each page to have the same width. 493 */ 494 int maxChildHeight = 0; 495 496 final int verticalPadding = getPaddingTop() + getPaddingBottom(); 497 final int horizontalPadding = getPaddingLeft() + getPaddingRight(); 498 499 500 // The children are given the same width and height as the workspace 501 // unless they were set to WRAP_CONTENT 502 if (DEBUG) Log.d(TAG, "PagedView.onMeasure(): " + widthSize + ", " + heightSize); 503 final int childCount = getChildCount(); 504 for (int i = 0; i < childCount; i++) { 505 // disallowing padding in paged view (just pass 0) 506 final View child = getPageAt(i); 507 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 508 509 int childWidthMode; 510 if (lp.width == LayoutParams.WRAP_CONTENT) { 511 childWidthMode = MeasureSpec.AT_MOST; 512 } else { 513 childWidthMode = MeasureSpec.EXACTLY; 514 } 515 516 int childHeightMode; 517 if (lp.height == LayoutParams.WRAP_CONTENT) { 518 childHeightMode = MeasureSpec.AT_MOST; 519 } else { 520 childHeightMode = MeasureSpec.EXACTLY; 521 } 522 523 final int childWidthMeasureSpec = 524 MeasureSpec.makeMeasureSpec(widthSize - horizontalPadding, childWidthMode); 525 final int childHeightMeasureSpec = 526 MeasureSpec.makeMeasureSpec(heightSize - verticalPadding, childHeightMode); 527 528 child.measure(childWidthMeasureSpec, childHeightMeasureSpec); 529 maxChildHeight = Math.max(maxChildHeight, child.getMeasuredHeight()); 530 if (DEBUG) Log.d(TAG, "\tmeasure-child" + i + ": " + child.getMeasuredWidth() + ", " 531 + child.getMeasuredHeight()); 532 } 533 534 if (heightMode == MeasureSpec.AT_MOST) { 535 heightSize = maxChildHeight + verticalPadding; 536 } 537 538 setMeasuredDimension(widthSize, heightSize); 539 540 // We can't call getChildOffset/getRelativeChildOffset until we set the measured dimensions. 541 // We also wait until we set the measured dimensions before flushing the cache as well, to 542 // ensure that the cache is filled with good values. 543 invalidateCachedOffsets(); 544 545 if (childCount > 0) { 546 if (DEBUG) Log.d(TAG, "getRelativeChildOffset(): " + getMeasuredWidth() + ", " 547 + getChildWidth(0)); 548 549 // Calculate the variable page spacing if necessary 550 if (mPageSpacing == AUTOMATIC_PAGE_SPACING) { 551 // The gap between pages in the PagedView should be equal to the gap from the page 552 // to the edge of the screen (so it is not visible in the current screen). To 553 // account for unequal padding on each side of the paged view, we take the maximum 554 // of the left/right gap and use that as the gap between each page. 555 int offset = getRelativeChildOffset(0); 556 int spacing = Math.max(offset, widthSize - offset - 557 getChildAt(0).getMeasuredWidth()); 558 setPageSpacing(spacing); 559 } 560 } 561 562 updateScrollingIndicatorPosition(); 563 564 if (childCount > 0) { 565 mMaxScrollX = getChildOffset(childCount - 1) - getRelativeChildOffset(childCount - 1); 566 } else { 567 mMaxScrollX = 0; 568 } 569 } 570 571 protected void scrollToNewPageWithoutMovingPages(int newCurrentPage) { 572 int newX = getChildOffset(newCurrentPage) - getRelativeChildOffset(newCurrentPage); 573 int delta = newX - getScrollX(); 574 575 final int pageCount = getChildCount(); 576 for (int i = 0; i < pageCount; i++) { 577 View page = (View) getPageAt(i); 578 page.setX(page.getX() + delta); 579 } 580 setCurrentPage(newCurrentPage); 581 } 582 583 // A layout scale of 1.0f assumes that the pages, in their unshrunken state, have a 584 // scale of 1.0f. A layout scale of 0.8f assumes the pages have a scale of 0.8f, and 585 // tightens the layout accordingly 586 public void setLayoutScale(float childrenScale) { 587 mLayoutScale = childrenScale; 588 invalidateCachedOffsets(); 589 590 // Now we need to do a re-layout, but preserving absolute X and Y coordinates 591 int childCount = getChildCount(); 592 float childrenX[] = new float[childCount]; 593 float childrenY[] = new float[childCount]; 594 for (int i = 0; i < childCount; i++) { 595 final View child = getPageAt(i); 596 childrenX[i] = child.getX(); 597 childrenY[i] = child.getY(); 598 } 599 // Trigger a full re-layout (never just call onLayout directly!) 600 int widthSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY); 601 int heightSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY); 602 requestLayout(); 603 measure(widthSpec, heightSpec); 604 layout(getLeft(), getTop(), getRight(), getBottom()); 605 for (int i = 0; i < childCount; i++) { 606 final View child = getPageAt(i); 607 child.setX(childrenX[i]); 608 child.setY(childrenY[i]); 609 } 610 611 // Also, the page offset has changed (since the pages are now smaller); 612 // update the page offset, but again preserving absolute X and Y coordinates 613 scrollToNewPageWithoutMovingPages(mCurrentPage); 614 } 615 616 public void setPageSpacing(int pageSpacing) { 617 mPageSpacing = pageSpacing; 618 invalidateCachedOffsets(); 619 } 620 621 @Override 622 protected void onLayout(boolean changed, int left, int top, int right, int bottom) { 623 if (!mIsDataReady) { 624 return; 625 } 626 627 if (DEBUG) Log.d(TAG, "PagedView.onLayout()"); 628 final int verticalPadding = getPaddingTop() + getPaddingBottom(); 629 final int childCount = getChildCount(); 630 int childLeft = getRelativeChildOffset(0); 631 632 for (int i = 0; i < childCount; i++) { 633 final View child = getPageAt(i); 634 if (child.getVisibility() != View.GONE) { 635 final int childWidth = getScaledMeasuredWidth(child); 636 final int childHeight = child.getMeasuredHeight(); 637 int childTop = getPaddingTop(); 638 if (mCenterPagesVertically) { 639 childTop += ((getMeasuredHeight() - verticalPadding) - childHeight) / 2; 640 } 641 642 if (DEBUG) Log.d(TAG, "\tlayout-child" + i + ": " + childLeft + ", " + childTop); 643 child.layout(childLeft, childTop, 644 childLeft + child.getMeasuredWidth(), childTop + childHeight); 645 childLeft += childWidth + mPageSpacing; 646 } 647 } 648 649 if (mFirstLayout && mCurrentPage >= 0 && mCurrentPage < getChildCount()) { 650 setHorizontalScrollBarEnabled(false); 651 updateCurrentPageScroll(); 652 setHorizontalScrollBarEnabled(true); 653 mFirstLayout = false; 654 } 655 } 656 657 protected void screenScrolled(int screenCenter) { 658 if (isScrollingIndicatorEnabled()) { 659 updateScrollingIndicator(); 660 } 661 boolean isInOverscroll = mOverScrollX < 0 || mOverScrollX > mMaxScrollX; 662 663 if (mFadeInAdjacentScreens && !isInOverscroll) { 664 for (int i = 0; i < getChildCount(); i++) { 665 View child = getChildAt(i); 666 if (child != null) { 667 float scrollProgress = getScrollProgress(screenCenter, child, i); 668 float alpha = 1 - Math.abs(scrollProgress); 669 child.setAlpha(alpha); 670 } 671 } 672 invalidate(); 673 } 674 } 675 676 @Override 677 public void onChildViewAdded(View parent, View child) { 678 // This ensures that when children are added, they get the correct transforms / alphas 679 // in accordance with any scroll effects. 680 mForceScreenScrolled = true; 681 invalidate(); 682 invalidateCachedOffsets(); 683 } 684 685 @Override 686 public void onChildViewRemoved(View parent, View child) { 687 } 688 689 protected void invalidateCachedOffsets() { 690 int count = getChildCount(); 691 if (count == 0) { 692 mChildOffsets = null; 693 mChildRelativeOffsets = null; 694 mChildOffsetsWithLayoutScale = null; 695 return; 696 } 697 698 mChildOffsets = new int[count]; 699 mChildRelativeOffsets = new int[count]; 700 mChildOffsetsWithLayoutScale = new int[count]; 701 for (int i = 0; i < count; i++) { 702 mChildOffsets[i] = -1; 703 mChildRelativeOffsets[i] = -1; 704 mChildOffsetsWithLayoutScale[i] = -1; 705 } 706 } 707 708 protected int getChildOffset(int index) { 709 int[] childOffsets = Float.compare(mLayoutScale, 1f) == 0 ? 710 mChildOffsets : mChildOffsetsWithLayoutScale; 711 712 if (childOffsets != null && childOffsets[index] != -1) { 713 return childOffsets[index]; 714 } else { 715 if (getChildCount() == 0) 716 return 0; 717 718 int offset = getRelativeChildOffset(0); 719 for (int i = 0; i < index; ++i) { 720 offset += getScaledMeasuredWidth(getPageAt(i)) + mPageSpacing; 721 } 722 if (childOffsets != null) { 723 childOffsets[index] = offset; 724 } 725 return offset; 726 } 727 } 728 729 protected int getRelativeChildOffset(int index) { 730 if (mChildRelativeOffsets != null && mChildRelativeOffsets[index] != -1) { 731 return mChildRelativeOffsets[index]; 732 } else { 733 final int padding = getPaddingLeft() + getPaddingRight(); 734 final int offset = getPaddingLeft() + 735 (getMeasuredWidth() - padding - getChildWidth(index)) / 2; 736 if (mChildRelativeOffsets != null) { 737 mChildRelativeOffsets[index] = offset; 738 } 739 return offset; 740 } 741 } 742 743 protected int getScaledMeasuredWidth(View child) { 744 // This functions are called enough times that it actually makes a difference in the 745 // profiler -- so just inline the max() here 746 final int measuredWidth = child.getMeasuredWidth(); 747 final int minWidth = mMinimumWidth; 748 final int maxWidth = (minWidth > measuredWidth) ? minWidth : measuredWidth; 749 return (int) (maxWidth * mLayoutScale + 0.5f); 750 } 751 752 protected void getVisiblePages(int[] range) { 753 final int pageCount = getChildCount(); 754 755 if (pageCount > 0) { 756 final int screenWidth = getMeasuredWidth(); 757 int leftScreen = 0; 758 int rightScreen = 0; 759 View currPage = getPageAt(leftScreen); 760 while (leftScreen < pageCount - 1 && 761 currPage.getX() + currPage.getWidth() - 762 currPage.getPaddingRight() < getScrollX()) { 763 leftScreen++; 764 currPage = getPageAt(leftScreen); 765 } 766 rightScreen = leftScreen; 767 currPage = getPageAt(rightScreen + 1); 768 while (rightScreen < pageCount - 1 && 769 currPage.getX() - currPage.getPaddingLeft() < getScrollX() + screenWidth) { 770 rightScreen++; 771 currPage = getPageAt(rightScreen + 1); 772 } 773 range[0] = leftScreen; 774 range[1] = rightScreen; 775 } else { 776 range[0] = -1; 777 range[1] = -1; 778 } 779 } 780 781 protected boolean shouldDrawChild(View child) { 782 return child.getAlpha() > 0; 783 } 784 785 @Override 786 protected void dispatchDraw(Canvas canvas) { 787 int halfScreenSize = getMeasuredWidth() / 2; 788 // mOverScrollX is equal to getScrollX() when we're within the normal scroll range. 789 // Otherwise it is equal to the scaled overscroll position. 790 int screenCenter = mOverScrollX + halfScreenSize; 791 792 if (screenCenter != mLastScreenCenter || mForceScreenScrolled) { 793 // set mForceScreenScrolled before calling screenScrolled so that screenScrolled can 794 // set it for the next frame 795 mForceScreenScrolled = false; 796 screenScrolled(screenCenter); 797 mLastScreenCenter = screenCenter; 798 } 799 800 // Find out which screens are visible; as an optimization we only call draw on them 801 final int pageCount = getChildCount(); 802 if (pageCount > 0) { 803 getVisiblePages(mTempVisiblePagesRange); 804 final int leftScreen = mTempVisiblePagesRange[0]; 805 final int rightScreen = mTempVisiblePagesRange[1]; 806 if (leftScreen != -1 && rightScreen != -1) { 807 final long drawingTime = getDrawingTime(); 808 // Clip to the bounds 809 canvas.save(); 810 canvas.clipRect(getScrollX(), getScrollY(), getScrollX() + getRight() - getLeft(), 811 getScrollY() + getBottom() - getTop()); 812 813 for (int i = getChildCount() - 1; i >= 0; i--) { 814 final View v = getPageAt(i); 815 if (mForceDrawAllChildrenNextFrame || 816 (leftScreen <= i && i <= rightScreen && shouldDrawChild(v))) { 817 drawChild(canvas, v, drawingTime); 818 } 819 } 820 mForceDrawAllChildrenNextFrame = false; 821 canvas.restore(); 822 } 823 } 824 } 825 826 @Override 827 public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) { 828 int page = indexToPage(indexOfChild(child)); 829 if (page != mCurrentPage || !mScroller.isFinished()) { 830 snapToPage(page); 831 return true; 832 } 833 return false; 834 } 835 836 @Override 837 protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) { 838 int focusablePage; 839 if (mNextPage != INVALID_PAGE) { 840 focusablePage = mNextPage; 841 } else { 842 focusablePage = mCurrentPage; 843 } 844 View v = getPageAt(focusablePage); 845 if (v != null) { 846 return v.requestFocus(direction, previouslyFocusedRect); 847 } 848 return false; 849 } 850 851 @Override 852 public boolean dispatchUnhandledMove(View focused, int direction) { 853 if (direction == View.FOCUS_LEFT) { 854 if (getCurrentPage() > 0) { 855 snapToPage(getCurrentPage() - 1); 856 return true; 857 } 858 } else if (direction == View.FOCUS_RIGHT) { 859 if (getCurrentPage() < getPageCount() - 1) { 860 snapToPage(getCurrentPage() + 1); 861 return true; 862 } 863 } 864 return super.dispatchUnhandledMove(focused, direction); 865 } 866 867 @Override 868 public void addFocusables(ArrayList<View> views, int direction, int focusableMode) { 869 if (mCurrentPage >= 0 && mCurrentPage < getPageCount()) { 870 getPageAt(mCurrentPage).addFocusables(views, direction, focusableMode); 871 } 872 if (direction == View.FOCUS_LEFT) { 873 if (mCurrentPage > 0) { 874 getPageAt(mCurrentPage - 1).addFocusables(views, direction, focusableMode); 875 } 876 } else if (direction == View.FOCUS_RIGHT){ 877 if (mCurrentPage < getPageCount() - 1) { 878 getPageAt(mCurrentPage + 1).addFocusables(views, direction, focusableMode); 879 } 880 } 881 } 882 883 /** 884 * If one of our descendant views decides that it could be focused now, only 885 * pass that along if it's on the current page. 886 * 887 * This happens when live folders requery, and if they're off page, they 888 * end up calling requestFocus, which pulls it on page. 889 */ 890 @Override 891 public void focusableViewAvailable(View focused) { 892 View current = getPageAt(mCurrentPage); 893 View v = focused; 894 while (true) { 895 if (v == current) { 896 super.focusableViewAvailable(focused); 897 return; 898 } 899 if (v == this) { 900 return; 901 } 902 ViewParent parent = v.getParent(); 903 if (parent instanceof View) { 904 v = (View)v.getParent(); 905 } else { 906 return; 907 } 908 } 909 } 910 911 /** 912 * {@inheritDoc} 913 */ 914 @Override 915 public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) { 916 if (disallowIntercept) { 917 // We need to make sure to cancel our long press if 918 // a scrollable widget takes over touch events 919 final View currentPage = getPageAt(mCurrentPage); 920 currentPage.cancelLongPress(); 921 } 922 super.requestDisallowInterceptTouchEvent(disallowIntercept); 923 } 924 925 /** 926 * Return true if a tap at (x, y) should trigger a flip to the previous page. 927 */ 928 protected boolean hitsPreviousPage(float x, float y) { 929 return (x < getRelativeChildOffset(mCurrentPage) - mPageSpacing); 930 } 931 932 /** 933 * Return true if a tap at (x, y) should trigger a flip to the next page. 934 */ 935 protected boolean hitsNextPage(float x, float y) { 936 return (x > (getMeasuredWidth() - getRelativeChildOffset(mCurrentPage) + mPageSpacing)); 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 acquireVelocityTrackerAndAddMovement(ev); 947 948 // Skip touch handling if there are no pages to swipe 949 if (getChildCount() <= 0) return super.onInterceptTouchEvent(ev); 950 951 /* 952 * Shortcut the most recurring case: the user is in the dragging 953 * state and he is moving his finger. We want to intercept this 954 * motion. 955 */ 956 final int action = ev.getAction(); 957 if ((action == MotionEvent.ACTION_MOVE) && 958 (mTouchState == TOUCH_STATE_SCROLLING)) { 959 return true; 960 } 961 962 switch (action & MotionEvent.ACTION_MASK) { 963 case MotionEvent.ACTION_MOVE: { 964 /* 965 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check 966 * whether the user has moved far enough from his original down touch. 967 */ 968 if (mActivePointerId != INVALID_POINTER) { 969 determineScrollingStart(ev); 970 break; 971 } 972 // if mActivePointerId is INVALID_POINTER, then we must have missed an ACTION_DOWN 973 // event. in that case, treat the first occurence of a move event as a ACTION_DOWN 974 // i.e. fall through to the next case (don't break) 975 // (We sometimes miss ACTION_DOWN events in Workspace because it ignores all events 976 // while it's small- this was causing a crash before we checked for INVALID_POINTER) 977 } 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; 984 mLastMotionX = x; 985 mLastMotionY = y; 986 mLastMotionXRemainder = 0; 987 mTotalMotionX = 0; 988 mActivePointerId = ev.getPointerId(0); 989 mAllowLongPress = true; 990 991 /* 992 * If being flinged and user touches the screen, initiate drag; 993 * otherwise don't. mScroller.isFinished should be false when 994 * being flinged. 995 */ 996 final int xDist = Math.abs(mScroller.getFinalX() - mScroller.getCurrX()); 997 final boolean finishedScrolling = (mScroller.isFinished() || xDist < mTouchSlop); 998 if (finishedScrolling) { 999 mTouchState = TOUCH_STATE_REST; 1000 mScroller.abortAnimation(); 1001 } else { 1002 mTouchState = TOUCH_STATE_SCROLLING; 1003 } 1004 1005 // check if this can be the beginning of a tap on the side of the pages 1006 // to scroll the current page 1007 if (mTouchState != TOUCH_STATE_PREV_PAGE && mTouchState != TOUCH_STATE_NEXT_PAGE) { 1008 if (getChildCount() > 0) { 1009 if (hitsPreviousPage(x, y)) { 1010 mTouchState = TOUCH_STATE_PREV_PAGE; 1011 } else if (hitsNextPage(x, y)) { 1012 mTouchState = TOUCH_STATE_NEXT_PAGE; 1013 } 1014 } 1015 } 1016 break; 1017 } 1018 1019 case MotionEvent.ACTION_UP: 1020 case MotionEvent.ACTION_CANCEL: 1021 mTouchState = TOUCH_STATE_REST; 1022 mAllowLongPress = false; 1023 mActivePointerId = INVALID_POINTER; 1024 releaseVelocityTracker(); 1025 break; 1026 1027 case MotionEvent.ACTION_POINTER_UP: 1028 onSecondaryPointerUp(ev); 1029 releaseVelocityTracker(); 1030 break; 1031 } 1032 1033 /* 1034 * The only time we want to intercept motion events is if we are in the 1035 * drag mode. 1036 */ 1037 return mTouchState != TOUCH_STATE_REST; 1038 } 1039 1040 protected void determineScrollingStart(MotionEvent ev) { 1041 determineScrollingStart(ev, 1.0f); 1042 } 1043 1044 /* 1045 * Determines if we should change the touch state to start scrolling after the 1046 * user moves their touch point too far. 1047 */ 1048 protected void determineScrollingStart(MotionEvent ev, float touchSlopScale) { 1049 /* 1050 * Locally do absolute value. mLastMotionX is set to the y value 1051 * of the down event. 1052 */ 1053 final int pointerIndex = ev.findPointerIndex(mActivePointerId); 1054 if (pointerIndex == -1) { 1055 return; 1056 } 1057 final float x = ev.getX(pointerIndex); 1058 final float y = ev.getY(pointerIndex); 1059 final int xDiff = (int) Math.abs(x - mLastMotionX); 1060 final int yDiff = (int) Math.abs(y - mLastMotionY); 1061 1062 final int touchSlop = Math.round(touchSlopScale * mTouchSlop); 1063 boolean xPaged = xDiff > mPagingTouchSlop; 1064 boolean xMoved = xDiff > touchSlop; 1065 boolean yMoved = yDiff > touchSlop; 1066 1067 if (xMoved || xPaged || yMoved) { 1068 if (mUsePagingTouchSlop ? xPaged : xMoved) { 1069 // Scroll if the user moved far enough along the X axis 1070 mTouchState = TOUCH_STATE_SCROLLING; 1071 mTotalMotionX += Math.abs(mLastMotionX - x); 1072 mLastMotionX = x; 1073 mLastMotionXRemainder = 0; 1074 mTouchX = getScrollX(); 1075 mSmoothingTime = System.nanoTime() / NANOTIME_DIV; 1076 pageBeginMoving(); 1077 } 1078 // Either way, cancel any pending longpress 1079 cancelCurrentPageLongPress(); 1080 } 1081 } 1082 1083 protected void cancelCurrentPageLongPress() { 1084 if (mAllowLongPress) { 1085 mAllowLongPress = false; 1086 // Try canceling the long press. It could also have been scheduled 1087 // by a distant descendant, so use the mAllowLongPress flag to block 1088 // everything 1089 final View currentPage = getPageAt(mCurrentPage); 1090 if (currentPage != null) { 1091 currentPage.cancelLongPress(); 1092 } 1093 } 1094 } 1095 1096 protected float getScrollProgress(int screenCenter, View v, int page) { 1097 final int halfScreenSize = getMeasuredWidth() / 2; 1098 1099 int totalDistance = getScaledMeasuredWidth(v) + mPageSpacing; 1100 int delta = screenCenter - (getChildOffset(page) - 1101 getRelativeChildOffset(page) + halfScreenSize); 1102 1103 float scrollProgress = delta / (totalDistance * 1.0f); 1104 scrollProgress = Math.min(scrollProgress, 1.0f); 1105 scrollProgress = Math.max(scrollProgress, -1.0f); 1106 return scrollProgress; 1107 } 1108 1109 // This curve determines how the effect of scrolling over the limits of the page dimishes 1110 // as the user pulls further and further from the bounds 1111 private float overScrollInfluenceCurve(float f) { 1112 f -= 1.0f; 1113 return f * f * f + 1.0f; 1114 } 1115 1116 protected void acceleratedOverScroll(float amount) { 1117 int screenSize = getMeasuredWidth(); 1118 1119 // We want to reach the max over scroll effect when the user has 1120 // over scrolled half the size of the screen 1121 float f = OVERSCROLL_ACCELERATE_FACTOR * (amount / screenSize); 1122 1123 if (f == 0) return; 1124 1125 // Clamp this factor, f, to -1 < f < 1 1126 if (Math.abs(f) >= 1) { 1127 f /= Math.abs(f); 1128 } 1129 1130 int overScrollAmount = (int) Math.round(f * screenSize); 1131 if (amount < 0) { 1132 mOverScrollX = overScrollAmount; 1133 super.scrollTo(0, getScrollY()); 1134 } else { 1135 mOverScrollX = mMaxScrollX + overScrollAmount; 1136 super.scrollTo(mMaxScrollX, getScrollY()); 1137 } 1138 invalidate(); 1139 } 1140 1141 protected void dampedOverScroll(float amount) { 1142 int screenSize = getMeasuredWidth(); 1143 1144 float f = (amount / screenSize); 1145 1146 if (f == 0) return; 1147 f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f))); 1148 1149 // Clamp this factor, f, to -1 < f < 1 1150 if (Math.abs(f) >= 1) { 1151 f /= Math.abs(f); 1152 } 1153 1154 int overScrollAmount = (int) Math.round(OVERSCROLL_DAMP_FACTOR * f * screenSize); 1155 if (amount < 0) { 1156 mOverScrollX = overScrollAmount; 1157 super.scrollTo(0, getScrollY()); 1158 } else { 1159 mOverScrollX = mMaxScrollX + overScrollAmount; 1160 super.scrollTo(mMaxScrollX, getScrollY()); 1161 } 1162 invalidate(); 1163 } 1164 1165 protected void overScroll(float amount) { 1166 dampedOverScroll(amount); 1167 } 1168 1169 protected float maxOverScroll() { 1170 // Using the formula in overScroll, assuming that f = 1.0 (which it should generally not 1171 // exceed). Used to find out how much extra wallpaper we need for the over scroll effect 1172 float f = 1.0f; 1173 f = f / (Math.abs(f)) * (overScrollInfluenceCurve(Math.abs(f))); 1174 return OVERSCROLL_DAMP_FACTOR * f; 1175 } 1176 1177 @Override 1178 public boolean onTouchEvent(MotionEvent ev) { 1179 // Skip touch handling if there are no pages to swipe 1180 if (getChildCount() <= 0) return super.onTouchEvent(ev); 1181 1182 acquireVelocityTrackerAndAddMovement(ev); 1183 1184 final int action = ev.getAction(); 1185 1186 switch (action & MotionEvent.ACTION_MASK) { 1187 case MotionEvent.ACTION_DOWN: 1188 /* 1189 * If being flinged and user touches, stop the fling. isFinished 1190 * will be false if being flinged. 1191 */ 1192 if (!mScroller.isFinished()) { 1193 mScroller.abortAnimation(); 1194 } 1195 1196 // Remember where the motion event started 1197 mDownMotionX = mLastMotionX = ev.getX(); 1198 mLastMotionXRemainder = 0; 1199 mTotalMotionX = 0; 1200 mActivePointerId = ev.getPointerId(0); 1201 if (mTouchState == TOUCH_STATE_SCROLLING) { 1202 pageBeginMoving(); 1203 } 1204 break; 1205 1206 case MotionEvent.ACTION_MOVE: 1207 if (mTouchState == TOUCH_STATE_SCROLLING) { 1208 // Scroll to follow the motion event 1209 final int pointerIndex = ev.findPointerIndex(mActivePointerId); 1210 final float x = ev.getX(pointerIndex); 1211 final float deltaX = mLastMotionX + mLastMotionXRemainder - x; 1212 1213 mTotalMotionX += Math.abs(deltaX); 1214 1215 // Only scroll and update mLastMotionX if we have moved some discrete amount. We 1216 // keep the remainder because we are actually testing if we've moved from the last 1217 // scrolled position (which is discrete). 1218 if (Math.abs(deltaX) >= 1.0f) { 1219 mTouchX += deltaX; 1220 mSmoothingTime = System.nanoTime() / NANOTIME_DIV; 1221 if (!mDeferScrollUpdate) { 1222 scrollBy((int) deltaX, 0); 1223 if (DEBUG) Log.d(TAG, "onTouchEvent().Scrolling: " + deltaX); 1224 } else { 1225 invalidate(); 1226 } 1227 mLastMotionX = x; 1228 mLastMotionXRemainder = deltaX - (int) deltaX; 1229 } else { 1230 awakenScrollBars(); 1231 } 1232 } else { 1233 determineScrollingStart(ev); 1234 } 1235 break; 1236 1237 case MotionEvent.ACTION_UP: 1238 if (mTouchState == TOUCH_STATE_SCROLLING) { 1239 final int activePointerId = mActivePointerId; 1240 final int pointerIndex = ev.findPointerIndex(activePointerId); 1241 final float x = ev.getX(pointerIndex); 1242 final VelocityTracker velocityTracker = mVelocityTracker; 1243 velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity); 1244 int velocityX = (int) velocityTracker.getXVelocity(activePointerId); 1245 final int deltaX = (int) (x - mDownMotionX); 1246 final int pageWidth = getScaledMeasuredWidth(getPageAt(mCurrentPage)); 1247 boolean isSignificantMove = Math.abs(deltaX) > pageWidth * 1248 SIGNIFICANT_MOVE_THRESHOLD; 1249 1250 mTotalMotionX += Math.abs(mLastMotionX + mLastMotionXRemainder - x); 1251 1252 boolean isFling = mTotalMotionX > MIN_LENGTH_FOR_FLING && 1253 Math.abs(velocityX) > mFlingThresholdVelocity; 1254 1255 // In the case that the page is moved far to one direction and then is flung 1256 // in the opposite direction, we use a threshold to determine whether we should 1257 // just return to the starting page, or if we should skip one further. 1258 boolean returnToOriginalPage = false; 1259 if (Math.abs(deltaX) > pageWidth * RETURN_TO_ORIGINAL_PAGE_THRESHOLD && 1260 Math.signum(velocityX) != Math.signum(deltaX) && isFling) { 1261 returnToOriginalPage = true; 1262 } 1263 1264 int finalPage; 1265 // We give flings precedence over large moves, which is why we short-circuit our 1266 // test for a large move if a fling has been registered. That is, a large 1267 // move to the left and fling to the right will register as a fling to the right. 1268 if (((isSignificantMove && deltaX > 0 && !isFling) || 1269 (isFling && velocityX > 0)) && mCurrentPage > 0) { 1270 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage - 1; 1271 snapToPageWithVelocity(finalPage, velocityX); 1272 } else if (((isSignificantMove && deltaX < 0 && !isFling) || 1273 (isFling && velocityX < 0)) && 1274 mCurrentPage < getChildCount() - 1) { 1275 finalPage = returnToOriginalPage ? mCurrentPage : mCurrentPage + 1; 1276 snapToPageWithVelocity(finalPage, velocityX); 1277 } else { 1278 snapToDestination(); 1279 } 1280 } else if (mTouchState == TOUCH_STATE_PREV_PAGE) { 1281 // at this point we have not moved beyond the touch slop 1282 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so 1283 // we can just page 1284 int nextPage = Math.max(0, mCurrentPage - 1); 1285 if (nextPage != mCurrentPage) { 1286 snapToPage(nextPage); 1287 } else { 1288 snapToDestination(); 1289 } 1290 } else if (mTouchState == TOUCH_STATE_NEXT_PAGE) { 1291 // at this point we have not moved beyond the touch slop 1292 // (otherwise mTouchState would be TOUCH_STATE_SCROLLING), so 1293 // we can just page 1294 int nextPage = Math.min(getChildCount() - 1, mCurrentPage + 1); 1295 if (nextPage != mCurrentPage) { 1296 snapToPage(nextPage); 1297 } else { 1298 snapToDestination(); 1299 } 1300 } else { 1301 onUnhandledTap(ev); 1302 } 1303 mTouchState = TOUCH_STATE_REST; 1304 mActivePointerId = INVALID_POINTER; 1305 releaseVelocityTracker(); 1306 break; 1307 1308 case MotionEvent.ACTION_CANCEL: 1309 if (mTouchState == TOUCH_STATE_SCROLLING) { 1310 snapToDestination(); 1311 } 1312 mTouchState = TOUCH_STATE_REST; 1313 mActivePointerId = INVALID_POINTER; 1314 releaseVelocityTracker(); 1315 break; 1316 1317 case MotionEvent.ACTION_POINTER_UP: 1318 onSecondaryPointerUp(ev); 1319 break; 1320 } 1321 1322 return true; 1323 } 1324 1325 @Override 1326 public boolean onGenericMotionEvent(MotionEvent event) { 1327 if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0) { 1328 switch (event.getAction()) { 1329 case MotionEvent.ACTION_SCROLL: { 1330 // Handle mouse (or ext. device) by shifting the page depending on the scroll 1331 final float vscroll; 1332 final float hscroll; 1333 if ((event.getMetaState() & KeyEvent.META_SHIFT_ON) != 0) { 1334 vscroll = 0; 1335 hscroll = event.getAxisValue(MotionEvent.AXIS_VSCROLL); 1336 } else { 1337 vscroll = -event.getAxisValue(MotionEvent.AXIS_VSCROLL); 1338 hscroll = event.getAxisValue(MotionEvent.AXIS_HSCROLL); 1339 } 1340 if (hscroll != 0 || vscroll != 0) { 1341 if (hscroll > 0 || vscroll > 0) { 1342 scrollRight(); 1343 } else { 1344 scrollLeft(); 1345 } 1346 return true; 1347 } 1348 } 1349 } 1350 } 1351 return super.onGenericMotionEvent(event); 1352 } 1353 1354 private void acquireVelocityTrackerAndAddMovement(MotionEvent ev) { 1355 if (mVelocityTracker == null) { 1356 mVelocityTracker = VelocityTracker.obtain(); 1357 } 1358 mVelocityTracker.addMovement(ev); 1359 } 1360 1361 private void releaseVelocityTracker() { 1362 if (mVelocityTracker != null) { 1363 mVelocityTracker.recycle(); 1364 mVelocityTracker = null; 1365 } 1366 } 1367 1368 private void onSecondaryPointerUp(MotionEvent ev) { 1369 final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >> 1370 MotionEvent.ACTION_POINTER_INDEX_SHIFT; 1371 final int pointerId = ev.getPointerId(pointerIndex); 1372 if (pointerId == mActivePointerId) { 1373 // This was our active pointer going up. Choose a new 1374 // active pointer and adjust accordingly. 1375 // TODO: Make this decision more intelligent. 1376 final int newPointerIndex = pointerIndex == 0 ? 1 : 0; 1377 mLastMotionX = mDownMotionX = ev.getX(newPointerIndex); 1378 mLastMotionY = ev.getY(newPointerIndex); 1379 mLastMotionXRemainder = 0; 1380 mActivePointerId = ev.getPointerId(newPointerIndex); 1381 if (mVelocityTracker != null) { 1382 mVelocityTracker.clear(); 1383 } 1384 } 1385 } 1386 1387 protected void onUnhandledTap(MotionEvent ev) {} 1388 1389 @Override 1390 public void requestChildFocus(View child, View focused) { 1391 super.requestChildFocus(child, focused); 1392 int page = indexToPage(indexOfChild(child)); 1393 if (page >= 0 && page != getCurrentPage() && !isInTouchMode()) { 1394 snapToPage(page); 1395 } 1396 } 1397 1398 protected int getChildIndexForRelativeOffset(int relativeOffset) { 1399 final int childCount = getChildCount(); 1400 int left; 1401 int right; 1402 for (int i = 0; i < childCount; ++i) { 1403 left = getRelativeChildOffset(i); 1404 right = (left + getScaledMeasuredWidth(getPageAt(i))); 1405 if (left <= relativeOffset && relativeOffset <= right) { 1406 return i; 1407 } 1408 } 1409 return -1; 1410 } 1411 1412 protected int getChildWidth(int index) { 1413 // This functions are called enough times that it actually makes a difference in the 1414 // profiler -- so just inline the max() here 1415 final int measuredWidth = getPageAt(index).getMeasuredWidth(); 1416 final int minWidth = mMinimumWidth; 1417 return (minWidth > measuredWidth) ? minWidth : measuredWidth; 1418 } 1419 1420 int getPageNearestToCenterOfScreen() { 1421 int minDistanceFromScreenCenter = Integer.MAX_VALUE; 1422 int minDistanceFromScreenCenterIndex = -1; 1423 int screenCenter = getScrollX() + (getMeasuredWidth() / 2); 1424 final int childCount = getChildCount(); 1425 for (int i = 0; i < childCount; ++i) { 1426 View layout = (View) getPageAt(i); 1427 int childWidth = getScaledMeasuredWidth(layout); 1428 int halfChildWidth = (childWidth / 2); 1429 int childCenter = getChildOffset(i) + halfChildWidth; 1430 int distanceFromScreenCenter = Math.abs(childCenter - screenCenter); 1431 if (distanceFromScreenCenter < minDistanceFromScreenCenter) { 1432 minDistanceFromScreenCenter = distanceFromScreenCenter; 1433 minDistanceFromScreenCenterIndex = i; 1434 } 1435 } 1436 return minDistanceFromScreenCenterIndex; 1437 } 1438 1439 protected void snapToDestination() { 1440 snapToPage(getPageNearestToCenterOfScreen(), PAGE_SNAP_ANIMATION_DURATION); 1441 } 1442 1443 private static class ScrollInterpolator implements Interpolator { 1444 public ScrollInterpolator() { 1445 } 1446 1447 public float getInterpolation(float t) { 1448 t -= 1.0f; 1449 return t*t*t*t*t + 1; 1450 } 1451 } 1452 1453 // We want the duration of the page snap animation to be influenced by the distance that 1454 // the screen has to travel, however, we don't want this duration to be effected in a 1455 // purely linear fashion. Instead, we use this method to moderate the effect that the distance 1456 // of travel has on the overall snap duration. 1457 float distanceInfluenceForSnapDuration(float f) { 1458 f -= 0.5f; // center the values about 0. 1459 f *= 0.3f * Math.PI / 2.0f; 1460 return (float) Math.sin(f); 1461 } 1462 1463 protected void snapToPageWithVelocity(int whichPage, int velocity) { 1464 whichPage = Math.max(0, Math.min(whichPage, getChildCount() - 1)); 1465 int halfScreenSize = getMeasuredWidth() / 2; 1466 1467 if (DEBUG) Log.d(TAG, "snapToPage.getChildOffset(): " + getChildOffset(whichPage)); 1468 if (DEBUG) Log.d(TAG, "snapToPageWithVelocity.getRelativeChildOffset(): " 1469 + getMeasuredWidth() + ", " + getChildWidth(whichPage)); 1470 final int newX = getChildOffset(whichPage) - getRelativeChildOffset(whichPage); 1471 int delta = newX - mUnboundedScrollX; 1472 int duration = 0; 1473 1474 if (Math.abs(velocity) < mMinFlingVelocity) { 1475 // If the velocity is low enough, then treat this more as an automatic page advance 1476 // as opposed to an apparent physical response to flinging 1477 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION); 1478 return; 1479 } 1480 1481 // Here we compute a "distance" that will be used in the computation of the overall 1482 // snap duration. This is a function of the actual distance that needs to be traveled; 1483 // we keep this value close to half screen size in order to reduce the variance in snap 1484 // duration as a function of the distance the page needs to travel. 1485 float distanceRatio = Math.min(1f, 1.0f * Math.abs(delta) / (2 * halfScreenSize)); 1486 float distance = halfScreenSize + halfScreenSize * 1487 distanceInfluenceForSnapDuration(distanceRatio); 1488 1489 velocity = Math.abs(velocity); 1490 velocity = Math.max(mMinSnapVelocity, velocity); 1491 1492 // we want the page's snap velocity to approximately match the velocity at which the 1493 // user flings, so we scale the duration by a value near to the derivative of the scroll 1494 // interpolator at zero, ie. 5. We use 4 to make it a little slower. 1495 duration = 4 * Math.round(1000 * Math.abs(distance / velocity)); 1496 duration = Math.min(duration, MAX_PAGE_SNAP_DURATION); 1497 1498 snapToPage(whichPage, delta, duration); 1499 } 1500 1501 protected void snapToPage(int whichPage) { 1502 snapToPage(whichPage, PAGE_SNAP_ANIMATION_DURATION); 1503 } 1504 1505 protected void snapToPage(int whichPage, int duration) { 1506 whichPage = Math.max(0, Math.min(whichPage, getPageCount() - 1)); 1507 1508 if (DEBUG) Log.d(TAG, "snapToPage.getChildOffset(): " + getChildOffset(whichPage)); 1509 if (DEBUG) Log.d(TAG, "snapToPage.getRelativeChildOffset(): " + getMeasuredWidth() + ", " 1510 + getChildWidth(whichPage)); 1511 int newX = getChildOffset(whichPage) - getRelativeChildOffset(whichPage); 1512 final int sX = mUnboundedScrollX; 1513 final int delta = newX - sX; 1514 snapToPage(whichPage, delta, duration); 1515 } 1516 1517 protected void snapToPage(int whichPage, int delta, int duration) { 1518 mNextPage = whichPage; 1519 1520 View focusedChild = getFocusedChild(); 1521 if (focusedChild != null && whichPage != mCurrentPage && 1522 focusedChild == getPageAt(mCurrentPage)) { 1523 focusedChild.clearFocus(); 1524 } 1525 1526 pageBeginMoving(); 1527 awakenScrollBars(duration); 1528 if (duration == 0) { 1529 duration = Math.abs(delta); 1530 } 1531 1532 if (!mScroller.isFinished()) mScroller.abortAnimation(); 1533 mScroller.startScroll(mUnboundedScrollX, 0, delta, 0, duration); 1534 1535 // Load associated pages immediately if someone else is handling the scroll, otherwise defer 1536 // loading associated pages until the scroll settles 1537 if (mDeferScrollUpdate) { 1538 loadAssociatedPages(mNextPage); 1539 } else { 1540 mDeferLoadAssociatedPagesUntilScrollCompletes = true; 1541 } 1542 notifyPageSwitchListener(); 1543 invalidate(); 1544 } 1545 1546 public void scrollLeft() { 1547 if (mScroller.isFinished()) { 1548 if (mCurrentPage > 0) snapToPage(mCurrentPage - 1); 1549 } else { 1550 if (mNextPage > 0) snapToPage(mNextPage - 1); 1551 } 1552 } 1553 1554 public void scrollRight() { 1555 if (mScroller.isFinished()) { 1556 if (mCurrentPage < getChildCount() -1) snapToPage(mCurrentPage + 1); 1557 } else { 1558 if (mNextPage < getChildCount() -1) snapToPage(mNextPage + 1); 1559 } 1560 } 1561 1562 public int getPageForView(View v) { 1563 int result = -1; 1564 if (v != null) { 1565 ViewParent vp = v.getParent(); 1566 int count = getChildCount(); 1567 for (int i = 0; i < count; i++) { 1568 if (vp == getPageAt(i)) { 1569 return i; 1570 } 1571 } 1572 } 1573 return result; 1574 } 1575 1576 /** 1577 * @return True is long presses are still allowed for the current touch 1578 */ 1579 public boolean allowLongPress() { 1580 return mAllowLongPress; 1581 } 1582 1583 /** 1584 * Set true to allow long-press events to be triggered, usually checked by 1585 * {@link Launcher} to accept or block dpad-initiated long-presses. 1586 */ 1587 public void setAllowLongPress(boolean allowLongPress) { 1588 mAllowLongPress = allowLongPress; 1589 } 1590 1591 public static class SavedState extends BaseSavedState { 1592 int currentPage = -1; 1593 1594 SavedState(Parcelable superState) { 1595 super(superState); 1596 } 1597 1598 private SavedState(Parcel in) { 1599 super(in); 1600 currentPage = in.readInt(); 1601 } 1602 1603 @Override 1604 public void writeToParcel(Parcel out, int flags) { 1605 super.writeToParcel(out, flags); 1606 out.writeInt(currentPage); 1607 } 1608 1609 public static final Parcelable.Creator<SavedState> CREATOR = 1610 new Parcelable.Creator<SavedState>() { 1611 public SavedState createFromParcel(Parcel in) { 1612 return new SavedState(in); 1613 } 1614 1615 public SavedState[] newArray(int size) { 1616 return new SavedState[size]; 1617 } 1618 }; 1619 } 1620 1621 protected void loadAssociatedPages(int page) { 1622 loadAssociatedPages(page, false); 1623 } 1624 protected void loadAssociatedPages(int page, boolean immediateAndOnly) { 1625 if (mContentIsRefreshable) { 1626 final int count = getChildCount(); 1627 if (page < count) { 1628 int lowerPageBound = getAssociatedLowerPageBound(page); 1629 int upperPageBound = getAssociatedUpperPageBound(page); 1630 if (DEBUG) Log.d(TAG, "loadAssociatedPages: " + lowerPageBound + "/" 1631 + upperPageBound); 1632 // First, clear any pages that should no longer be loaded 1633 for (int i = 0; i < count; ++i) { 1634 Page layout = (Page) getPageAt(i); 1635 if ((i < lowerPageBound) || (i > upperPageBound)) { 1636 if (layout.getPageChildCount() > 0) { 1637 layout.removeAllViewsOnPage(); 1638 } 1639 mDirtyPageContent.set(i, true); 1640 } 1641 } 1642 // Next, load any new pages 1643 for (int i = 0; i < count; ++i) { 1644 if ((i != page) && immediateAndOnly) { 1645 continue; 1646 } 1647 if (lowerPageBound <= i && i <= upperPageBound) { 1648 if (mDirtyPageContent.get(i)) { 1649 syncPageItems(i, (i == page) && immediateAndOnly); 1650 mDirtyPageContent.set(i, false); 1651 } 1652 } 1653 } 1654 } 1655 } 1656 } 1657 1658 protected int getAssociatedLowerPageBound(int page) { 1659 return Math.max(0, page - 1); 1660 } 1661 protected int getAssociatedUpperPageBound(int page) { 1662 final int count = getChildCount(); 1663 return Math.min(page + 1, count - 1); 1664 } 1665 1666 /** 1667 * This method is called ONLY to synchronize the number of pages that the paged view has. 1668 * To actually fill the pages with information, implement syncPageItems() below. It is 1669 * guaranteed that syncPageItems() will be called for a particular page before it is shown, 1670 * and therefore, individual page items do not need to be updated in this method. 1671 */ 1672 public abstract void syncPages(); 1673 1674 /** 1675 * This method is called to synchronize the items that are on a particular page. If views on 1676 * the page can be reused, then they should be updated within this method. 1677 */ 1678 public abstract void syncPageItems(int page, boolean immediate); 1679 1680 protected void invalidatePageData() { 1681 invalidatePageData(-1, false); 1682 } 1683 protected void invalidatePageData(int currentPage) { 1684 invalidatePageData(currentPage, false); 1685 } 1686 protected void invalidatePageData(int currentPage, boolean immediateAndOnly) { 1687 if (!mIsDataReady) { 1688 return; 1689 } 1690 1691 if (mContentIsRefreshable) { 1692 // Force all scrolling-related behavior to end 1693 mScroller.forceFinished(true); 1694 mNextPage = INVALID_PAGE; 1695 1696 // Update all the pages 1697 syncPages(); 1698 1699 // We must force a measure after we've loaded the pages to update the content width and 1700 // to determine the full scroll width 1701 measure(MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY), 1702 MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY)); 1703 1704 // Set a new page as the current page if necessary 1705 if (currentPage > -1) { 1706 setCurrentPage(Math.min(getPageCount() - 1, currentPage)); 1707 } 1708 1709 // Mark each of the pages as dirty 1710 final int count = getChildCount(); 1711 mDirtyPageContent.clear(); 1712 for (int i = 0; i < count; ++i) { 1713 mDirtyPageContent.add(true); 1714 } 1715 1716 // Load any pages that are necessary for the current window of views 1717 loadAssociatedPages(mCurrentPage, immediateAndOnly); 1718 requestLayout(); 1719 } 1720 } 1721 1722 protected View getScrollingIndicator() { 1723 // We use mHasScrollIndicator to prevent future lookups if there is no sibling indicator 1724 // found 1725 if (mHasScrollIndicator && mScrollIndicator == null) { 1726 ViewGroup parent = (ViewGroup) getParent(); 1727 if (parent != null) { 1728 mScrollIndicator = (View) (parent.findViewById(R.id.paged_view_indicator)); 1729 mHasScrollIndicator = mScrollIndicator != null; 1730 if (mHasScrollIndicator) { 1731 mScrollIndicator.setVisibility(View.VISIBLE); 1732 } 1733 } 1734 } 1735 return mScrollIndicator; 1736 } 1737 1738 protected boolean isScrollingIndicatorEnabled() { 1739 return true; 1740 } 1741 1742 Runnable hideScrollingIndicatorRunnable = new Runnable() { 1743 @Override 1744 public void run() { 1745 hideScrollingIndicator(false); 1746 } 1747 }; 1748 protected void flashScrollingIndicator(boolean animated) { 1749 removeCallbacks(hideScrollingIndicatorRunnable); 1750 showScrollingIndicator(!animated); 1751 postDelayed(hideScrollingIndicatorRunnable, sScrollIndicatorFlashDuration); 1752 } 1753 1754 protected void showScrollingIndicator(boolean immediately) { 1755 mShouldShowScrollIndicator = true; 1756 mShouldShowScrollIndicatorImmediately = true; 1757 if (getChildCount() <= 1) return; 1758 if (!isScrollingIndicatorEnabled()) return; 1759 1760 mShouldShowScrollIndicator = false; 1761 getScrollingIndicator(); 1762 if (mScrollIndicator != null) { 1763 // Fade the indicator in 1764 updateScrollingIndicatorPosition(); 1765 mScrollIndicator.setVisibility(View.VISIBLE); 1766 cancelScrollingIndicatorAnimations(); 1767 if (immediately || mScrollingPaused) { 1768 mScrollIndicator.setAlpha(1f); 1769 } else { 1770 mScrollIndicatorAnimator = LauncherAnimUtils.ofFloat(mScrollIndicator, "alpha", 1f); 1771 mScrollIndicatorAnimator.setDuration(sScrollIndicatorFadeInDuration); 1772 mScrollIndicatorAnimator.start(); 1773 } 1774 } 1775 } 1776 1777 protected void cancelScrollingIndicatorAnimations() { 1778 if (mScrollIndicatorAnimator != null) { 1779 mScrollIndicatorAnimator.cancel(); 1780 } 1781 } 1782 1783 protected void hideScrollingIndicator(boolean immediately) { 1784 if (getChildCount() <= 1) return; 1785 if (!isScrollingIndicatorEnabled()) return; 1786 1787 getScrollingIndicator(); 1788 if (mScrollIndicator != null) { 1789 // Fade the indicator out 1790 updateScrollingIndicatorPosition(); 1791 cancelScrollingIndicatorAnimations(); 1792 if (immediately || mScrollingPaused) { 1793 mScrollIndicator.setVisibility(View.INVISIBLE); 1794 mScrollIndicator.setAlpha(0f); 1795 } else { 1796 mScrollIndicatorAnimator = LauncherAnimUtils.ofFloat(mScrollIndicator, "alpha", 0f); 1797 mScrollIndicatorAnimator.setDuration(sScrollIndicatorFadeOutDuration); 1798 mScrollIndicatorAnimator.addListener(new AnimatorListenerAdapter() { 1799 private boolean cancelled = false; 1800 @Override 1801 public void onAnimationCancel(android.animation.Animator animation) { 1802 cancelled = true; 1803 } 1804 @Override 1805 public void onAnimationEnd(Animator animation) { 1806 if (!cancelled) { 1807 mScrollIndicator.setVisibility(View.INVISIBLE); 1808 } 1809 } 1810 }); 1811 mScrollIndicatorAnimator.start(); 1812 } 1813 } 1814 } 1815 1816 /** 1817 * To be overridden by subclasses to determine whether the scroll indicator should stretch to 1818 * fill its space on the track or not. 1819 */ 1820 protected boolean hasElasticScrollIndicator() { 1821 return true; 1822 } 1823 1824 private void updateScrollingIndicator() { 1825 if (getChildCount() <= 1) return; 1826 if (!isScrollingIndicatorEnabled()) return; 1827 1828 getScrollingIndicator(); 1829 if (mScrollIndicator != null) { 1830 updateScrollingIndicatorPosition(); 1831 } 1832 if (mShouldShowScrollIndicator) { 1833 showScrollingIndicator(mShouldShowScrollIndicatorImmediately); 1834 } 1835 } 1836 1837 private void updateScrollingIndicatorPosition() { 1838 if (!isScrollingIndicatorEnabled()) return; 1839 if (mScrollIndicator == null) return; 1840 int numPages = getChildCount(); 1841 int pageWidth = getMeasuredWidth(); 1842 int lastChildIndex = Math.max(0, getChildCount() - 1); 1843 int maxScrollX = getChildOffset(lastChildIndex) - getRelativeChildOffset(lastChildIndex); 1844 int trackWidth = pageWidth - mScrollIndicatorPaddingLeft - mScrollIndicatorPaddingRight; 1845 int indicatorWidth = mScrollIndicator.getMeasuredWidth() - 1846 mScrollIndicator.getPaddingLeft() - mScrollIndicator.getPaddingRight(); 1847 1848 float offset = Math.max(0f, Math.min(1f, (float) getScrollX() / maxScrollX)); 1849 int indicatorSpace = trackWidth / numPages; 1850 int indicatorPos = (int) (offset * (trackWidth - indicatorSpace)) + mScrollIndicatorPaddingLeft; 1851 if (hasElasticScrollIndicator()) { 1852 if (mScrollIndicator.getMeasuredWidth() != indicatorSpace) { 1853 mScrollIndicator.getLayoutParams().width = indicatorSpace; 1854 mScrollIndicator.requestLayout(); 1855 } 1856 } else { 1857 int indicatorCenterOffset = indicatorSpace / 2 - indicatorWidth / 2; 1858 indicatorPos += indicatorCenterOffset; 1859 } 1860 mScrollIndicator.setTranslationX(indicatorPos); 1861 } 1862 1863 public void showScrollIndicatorTrack() { 1864 } 1865 1866 public void hideScrollIndicatorTrack() { 1867 } 1868 1869 /* Accessibility */ 1870 @Override 1871 public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) { 1872 super.onInitializeAccessibilityNodeInfo(info); 1873 info.setScrollable(getPageCount() > 1); 1874 if (getCurrentPage() < getPageCount() - 1) { 1875 info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_FORWARD); 1876 } 1877 if (getCurrentPage() > 0) { 1878 info.addAction(AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD); 1879 } 1880 } 1881 1882 @Override 1883 public void onInitializeAccessibilityEvent(AccessibilityEvent event) { 1884 super.onInitializeAccessibilityEvent(event); 1885 event.setScrollable(true); 1886 if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_SCROLLED) { 1887 event.setFromIndex(mCurrentPage); 1888 event.setToIndex(mCurrentPage); 1889 event.setItemCount(getChildCount()); 1890 } 1891 } 1892 1893 @Override 1894 public boolean performAccessibilityAction(int action, Bundle arguments) { 1895 if (super.performAccessibilityAction(action, arguments)) { 1896 return true; 1897 } 1898 switch (action) { 1899 case AccessibilityNodeInfo.ACTION_SCROLL_FORWARD: { 1900 if (getCurrentPage() < getPageCount() - 1) { 1901 scrollRight(); 1902 return true; 1903 } 1904 } break; 1905 case AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD: { 1906 if (getCurrentPage() > 0) { 1907 scrollLeft(); 1908 return true; 1909 } 1910 } break; 1911 } 1912 return false; 1913 } 1914 1915 protected String getCurrentPageDescription() { 1916 return String.format(getContext().getString(R.string.default_scroll_format), 1917 getNextPage() + 1, getChildCount()); 1918 } 1919 1920 @Override 1921 public boolean onHoverEvent(android.view.MotionEvent event) { 1922 return true; 1923 } 1924 } 1925