GridLayoutManager.java revision a2aafea6e51bb33581853e16c21d546b316a52a3
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except 5 * in compliance with the License. You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software distributed under the License 10 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express 11 * or implied. See the License for the specific language governing permissions and limitations under 12 * the License. 13 */ 14package android.support.v17.leanback.widget; 15 16import android.content.Context; 17import android.graphics.PointF; 18import android.graphics.Rect; 19import android.os.Bundle; 20import android.os.Parcel; 21import android.os.Parcelable; 22import android.support.v4.util.CircularIntArray; 23import android.support.v4.view.ViewCompat; 24import android.support.v4.view.accessibility.AccessibilityEventCompat; 25import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat; 26import android.support.v4.view.accessibility.AccessibilityRecordCompat; 27import android.support.v7.widget.LinearSmoothScroller; 28import android.support.v7.widget.RecyclerView; 29import android.support.v7.widget.RecyclerView.Recycler; 30import android.support.v7.widget.RecyclerView.State; 31import android.support.v17.leanback.os.TraceHelper; 32 33import static android.support.v7.widget.RecyclerView.NO_ID; 34import static android.support.v7.widget.RecyclerView.NO_POSITION; 35import static android.support.v7.widget.RecyclerView.HORIZONTAL; 36import static android.support.v7.widget.RecyclerView.VERTICAL; 37 38import android.util.AttributeSet; 39import android.util.Log; 40import android.view.FocusFinder; 41import android.view.Gravity; 42import android.view.View; 43import android.view.ViewParent; 44import android.view.View.MeasureSpec; 45import android.view.ViewGroup.MarginLayoutParams; 46import android.view.ViewGroup; 47 48import java.io.PrintWriter; 49import java.io.StringWriter; 50import java.util.ArrayList; 51import java.util.List; 52 53final class GridLayoutManager extends RecyclerView.LayoutManager { 54 55 /* 56 * LayoutParams for {@link HorizontalGridView} and {@link VerticalGridView}. 57 * The class currently does two internal jobs: 58 * - Saves optical bounds insets. 59 * - Caches focus align view center. 60 */ 61 final static class LayoutParams extends RecyclerView.LayoutParams { 62 63 // For placement 64 private int mLeftInset; 65 private int mTopInset; 66 private int mRightInset; 67 private int mBottomInset; 68 69 // For alignment 70 private int mAlignX; 71 private int mAlignY; 72 private int[] mAlignMultiple; 73 private ItemAlignmentFacet mAlignmentFacet; 74 75 public LayoutParams(Context c, AttributeSet attrs) { 76 super(c, attrs); 77 } 78 79 public LayoutParams(int width, int height) { 80 super(width, height); 81 } 82 83 public LayoutParams(MarginLayoutParams source) { 84 super(source); 85 } 86 87 public LayoutParams(ViewGroup.LayoutParams source) { 88 super(source); 89 } 90 91 public LayoutParams(RecyclerView.LayoutParams source) { 92 super(source); 93 } 94 95 public LayoutParams(LayoutParams source) { 96 super(source); 97 } 98 99 int getAlignX() { 100 return mAlignX; 101 } 102 103 int getAlignY() { 104 return mAlignY; 105 } 106 107 int getOpticalLeft(View view) { 108 return view.getLeft() + mLeftInset; 109 } 110 111 int getOpticalTop(View view) { 112 return view.getTop() + mTopInset; 113 } 114 115 int getOpticalRight(View view) { 116 return view.getRight() - mRightInset; 117 } 118 119 int getOpticalBottom(View view) { 120 return view.getBottom() - mBottomInset; 121 } 122 123 int getOpticalWidth(View view) { 124 return view.getWidth() - mLeftInset - mRightInset; 125 } 126 127 int getOpticalHeight(View view) { 128 return view.getHeight() - mTopInset - mBottomInset; 129 } 130 131 int getDecoratedOpticalLeftWithMargin(RecyclerView.LayoutManager lm, View view) { 132 return lm.getDecoratedLeft(view) + mLeftInset - leftMargin; 133 } 134 135 int getDecoratedOpticalTopWithMargin(RecyclerView.LayoutManager lm, View view) { 136 return lm.getDecoratedTop(view) + mTopInset - topMargin; 137 } 138 139 int getDecoratedOpticalRightWithMargin(RecyclerView.LayoutManager lm, View view) { 140 return lm.getDecoratedRight(view) - mRightInset + rightMargin; 141 } 142 143 int getDecoratedOpticalBottomWithMargin(RecyclerView.LayoutManager lm, View view) { 144 return lm.getDecoratedBottom(view) - mBottomInset + bottomMargin; 145 } 146 147 int getDecoratedOpticalWidthWithMargin(RecyclerView.LayoutManager lm, View view) { 148 return lm.getDecoratedRight(view) - lm.getDecoratedLeft(view) 149 - mLeftInset - mRightInset + leftMargin + rightMargin; 150 } 151 152 int getDecoratedOpticalHeightWithMargin(RecyclerView.LayoutManager lm, View view) { 153 return lm.getDecoratedBottom(view) - lm.getDecoratedTop(view) 154 - mTopInset - mBottomInset + topMargin + bottomMargin; 155 } 156 157 int getOpticalLeftInset() { 158 return mLeftInset; 159 } 160 161 int getOpticalRightInset() { 162 return mRightInset; 163 } 164 165 int getOpticalTopInset() { 166 return mTopInset; 167 } 168 169 int getOpticalBottomInset() { 170 return mBottomInset; 171 } 172 173 void setAlignX(int alignX) { 174 mAlignX = alignX; 175 } 176 177 void setAlignY(int alignY) { 178 mAlignY = alignY; 179 } 180 181 void setItemAlignmentFacet(ItemAlignmentFacet facet) { 182 mAlignmentFacet = facet; 183 } 184 185 ItemAlignmentFacet getItemAlignmentFacet() { 186 return mAlignmentFacet; 187 } 188 189 void calculateItemAlignments(int orientation, View view) { 190 ItemAlignmentFacet.ItemAlignmentDef[] defs = mAlignmentFacet.getAlignmentDefs(); 191 if (mAlignMultiple == null || mAlignMultiple.length != defs.length) { 192 mAlignMultiple = new int[defs.length]; 193 } 194 for (int i = 0; i < defs.length; i++) { 195 mAlignMultiple[i] = ItemAlignmentFacetHelper 196 .getAlignmentPosition(view, defs[i], orientation); 197 } 198 if (orientation == HORIZONTAL) { 199 mAlignX = mAlignMultiple[0]; 200 } else { 201 mAlignY = mAlignMultiple[0]; 202 } 203 } 204 205 int[] getAlignMultiple() { 206 return mAlignMultiple; 207 } 208 209 void setOpticalInsets(int leftInset, int topInset, int rightInset, int bottomInset) { 210 mLeftInset = leftInset; 211 mTopInset = topInset; 212 mRightInset = rightInset; 213 mBottomInset = bottomInset; 214 } 215 216 } 217 218 /** 219 * Base class which scrolls to selected view in onStop(). 220 */ 221 abstract class GridLinearSmoothScroller extends LinearSmoothScroller { 222 GridLinearSmoothScroller() { 223 super(mBaseGridView.getContext()); 224 } 225 226 @Override 227 protected void onStop() { 228 // onTargetFound() may not be called if we hit the "wall" first or get cancelled. 229 View targetView = findViewByPosition(getTargetPosition()); 230 if (targetView == null) { 231 if (getTargetPosition() >= 0) { 232 // if smooth scroller is stopped without target, immediately jumps 233 // to the target position. 234 scrollToSelection(mBaseGridView, getTargetPosition(), 0, false, 0); 235 } 236 super.onStop(); 237 return; 238 } 239 if (hasFocus()) { 240 mInSelection = true; 241 targetView.requestFocus(); 242 mInSelection = false; 243 } 244 dispatchChildSelected(); 245 super.onStop(); 246 } 247 248 @Override 249 protected int calculateTimeForScrolling(int dx) { 250 int ms = super.calculateTimeForScrolling(dx); 251 if (mWindowAlignment.mainAxis().getSize() > 0) { 252 float minMs = (float) MIN_MS_SMOOTH_SCROLL_MAIN_SCREEN / 253 mWindowAlignment.mainAxis().getSize() * dx; 254 if (ms < minMs) { 255 ms = (int) minMs; 256 } 257 } 258 return ms; 259 } 260 261 @Override 262 protected void onTargetFound(View targetView, 263 RecyclerView.State state, Action action) { 264 if (getScrollPosition(targetView, null, sTwoInts)) { 265 int dx, dy; 266 if (mOrientation == HORIZONTAL) { 267 dx = sTwoInts[0]; 268 dy = sTwoInts[1]; 269 } else { 270 dx = sTwoInts[1]; 271 dy = sTwoInts[0]; 272 } 273 final int distance = (int) Math.sqrt(dx * dx + dy * dy); 274 final int time = calculateTimeForDeceleration(distance); 275 action.update(dx, dy, time, mDecelerateInterpolator); 276 } 277 } 278 } 279 280 /** 281 * The SmoothScroller that remembers pending DPAD keys and consume pending keys 282 * during scroll. 283 */ 284 final class PendingMoveSmoothScroller extends GridLinearSmoothScroller { 285 // -2 is a target position that LinearSmoothScroller can never find until 286 // consumePendingMovesXXX() sets real targetPosition. 287 final static int TARGET_UNDEFINED = -2; 288 // whether the grid is staggered. 289 private final boolean mStaggeredGrid; 290 // Number of pending movements on primary direction, negative if PREV_ITEM. 291 private int mPendingMoves; 292 293 PendingMoveSmoothScroller(int initialPendingMoves, boolean staggeredGrid) { 294 mPendingMoves = initialPendingMoves; 295 mStaggeredGrid = staggeredGrid; 296 setTargetPosition(TARGET_UNDEFINED); 297 } 298 299 void increasePendingMoves() { 300 if (mPendingMoves < MAX_PENDING_MOVES) { 301 mPendingMoves++; 302 } 303 } 304 305 void decreasePendingMoves() { 306 if (mPendingMoves > -MAX_PENDING_MOVES) { 307 mPendingMoves--; 308 } 309 } 310 311 /** 312 * Called before laid out an item when non-staggered grid can handle pending movements 313 * by skipping "mNumRows" per movement; staggered grid will have to wait the item 314 * has been laid out in consumePendingMovesAfterLayout(). 315 */ 316 void consumePendingMovesBeforeLayout() { 317 if (mStaggeredGrid || mPendingMoves == 0) { 318 return; 319 } 320 View newSelected = null; 321 int startPos = mPendingMoves > 0 ? mFocusPosition + mNumRows : 322 mFocusPosition - mNumRows; 323 for (int pos = startPos; mPendingMoves != 0; 324 pos = mPendingMoves > 0 ? pos + mNumRows: pos - mNumRows) { 325 View v = findViewByPosition(pos); 326 if (v == null) { 327 break; 328 } 329 if (!canScrollTo(v)) { 330 continue; 331 } 332 newSelected = v; 333 mFocusPosition = pos; 334 mSubFocusPosition = 0; 335 if (mPendingMoves > 0) { 336 mPendingMoves--; 337 } else { 338 mPendingMoves++; 339 } 340 } 341 if (newSelected != null && hasFocus()) { 342 mInSelection = true; 343 newSelected.requestFocus(); 344 mInSelection = false; 345 } 346 } 347 348 /** 349 * Called after laid out an item. Staggered grid should find view on same 350 * Row and consume pending movements. 351 */ 352 void consumePendingMovesAfterLayout() { 353 if (mStaggeredGrid && mPendingMoves != 0) { 354 // consume pending moves, focus to item on the same row. 355 mPendingMoves = processSelectionMoves(true, mPendingMoves); 356 } 357 if (mPendingMoves == 0 || (mPendingMoves > 0 && hasCreatedLastItem()) 358 || (mPendingMoves < 0 && hasCreatedFirstItem())) { 359 setTargetPosition(mFocusPosition); 360 stop(); 361 } 362 } 363 364 @Override 365 protected void updateActionForInterimTarget(Action action) { 366 if (mPendingMoves == 0) { 367 return; 368 } 369 super.updateActionForInterimTarget(action); 370 } 371 372 @Override 373 public PointF computeScrollVectorForPosition(int targetPosition) { 374 if (mPendingMoves == 0) { 375 return null; 376 } 377 int direction = (mReverseFlowPrimary ? mPendingMoves > 0 : mPendingMoves < 0) ? 378 -1 : 1; 379 if (mOrientation == HORIZONTAL) { 380 return new PointF(direction, 0); 381 } else { 382 return new PointF(0, direction); 383 } 384 } 385 386 @Override 387 protected void onStop() { 388 super.onStop(); 389 // if we hit wall, need clear the remaining pending moves. 390 mPendingMoves = 0; 391 mPendingMoveSmoothScroller = null; 392 View v = findViewByPosition(getTargetPosition()); 393 if (v != null) scrollToView(v, true); 394 } 395 }; 396 397 private static final String TAG = "GridLayoutManager"; 398 private static final boolean DEBUG = false; 399 private static final boolean TRACE = false; 400 401 // maximum pending movement in one direction. 402 private final static int MAX_PENDING_MOVES = 10; 403 // minimal milliseconds to scroll window size in major direction, we put a cap to prevent the 404 // effect smooth scrolling too over to bind an item view then drag the item view back. 405 private final static int MIN_MS_SMOOTH_SCROLL_MAIN_SCREEN = 30; 406 407 private String getTag() { 408 return TAG + ":" + mBaseGridView.getId(); 409 } 410 411 private final BaseGridView mBaseGridView; 412 413 /** 414 * Note on conventions in the presence of RTL layout directions: 415 * Many properties and method names reference entities related to the 416 * beginnings and ends of things. In the presence of RTL flows, 417 * it may not be clear whether this is intended to reference a 418 * quantity that changes direction in RTL cases, or a quantity that 419 * does not. Here are the conventions in use: 420 * 421 * start/end: coordinate quantities - do reverse 422 * (optical) left/right: coordinate quantities - do not reverse 423 * low/high: coordinate quantities - do not reverse 424 * min/max: coordinate quantities - do not reverse 425 * scroll offset - coordinate quantities - do not reverse 426 * first/last: positional indices - do not reverse 427 * front/end: positional indices - do not reverse 428 * prepend/append: related to positional indices - do not reverse 429 * 430 * Note that although quantities do not reverse in RTL flows, their 431 * relationship does. In LTR flows, the first positional index is 432 * leftmost; in RTL flows, it is rightmost. Thus, anywhere that 433 * positional quantities are mapped onto coordinate quantities, 434 * the flow must be checked and the logic reversed. 435 */ 436 437 /** 438 * The orientation of a "row". 439 */ 440 private int mOrientation = HORIZONTAL; 441 442 private RecyclerView.State mState; 443 private RecyclerView.Recycler mRecycler; 444 445 private static final Rect sTempRect = new Rect(); 446 447 private boolean mInLayout; 448 private boolean mInScroll; 449 private boolean mInFastRelayout; 450 /** 451 * During full layout pass, when GridView had focus: onLayoutChildren will 452 * skip non-focusable child and adjust mFocusPosition. 453 */ 454 private boolean mInLayoutSearchFocus; 455 private boolean mInSelection = false; 456 457 private OnChildSelectedListener mChildSelectedListener = null; 458 459 private ArrayList<OnChildViewHolderSelectedListener> mChildViewHolderSelectedListeners = null; 460 461 private OnChildLaidOutListener mChildLaidOutListener = null; 462 463 /** 464 * The focused position, it's not the currently visually aligned position 465 * but it is the final position that we intend to focus on. If there are 466 * multiple setSelection() called, mFocusPosition saves last value. 467 */ 468 private int mFocusPosition = NO_POSITION; 469 470 /** 471 * A view can have mutliple alignment position, this is the index of which 472 * alignment is used, by default is 0. 473 */ 474 private int mSubFocusPosition = 0; 475 476 /** 477 * LinearSmoothScroller that consume pending DPAD movements. 478 */ 479 private PendingMoveSmoothScroller mPendingMoveSmoothScroller; 480 481 /** 482 * The offset to be applied to mFocusPosition, due to adapter change, on the next 483 * layout. Set to Integer.MIN_VALUE means we should stop adding delta to mFocusPosition 484 * until next layout cycler. 485 * TODO: This is somewhat duplication of RecyclerView getOldPosition() which is 486 * unfortunately cleared after prelayout. 487 */ 488 private int mFocusPositionOffset = 0; 489 490 /** 491 * Extra pixels applied on primary direction. 492 */ 493 private int mPrimaryScrollExtra; 494 495 /** 496 * Force a full layout under certain situations. E.g. Rows change, jump to invisible child. 497 */ 498 private boolean mForceFullLayout; 499 500 /** 501 * True if layout is enabled. 502 */ 503 private boolean mLayoutEnabled = true; 504 505 /** 506 * override child visibility 507 */ 508 private int mChildVisibility = -1; 509 510 /** 511 * The scroll offsets of the viewport relative to the entire view. 512 */ 513 private int mScrollOffsetPrimary; 514 private int mScrollOffsetSecondary; 515 516 /** 517 * User-specified row height/column width. Can be WRAP_CONTENT. 518 */ 519 private int mRowSizeSecondaryRequested; 520 521 /** 522 * The fixed size of each grid item in the secondary direction. This corresponds to 523 * the row height, equal for all rows. Grid items may have variable length 524 * in the primary direction. 525 */ 526 private int mFixedRowSizeSecondary; 527 528 /** 529 * Tracks the secondary size of each row. 530 */ 531 private int[] mRowSizeSecondary; 532 533 /** 534 * Flag controlling whether the current/next layout should 535 * be updating the secondary size of rows. 536 */ 537 private boolean mRowSecondarySizeRefresh; 538 539 /** 540 * The maximum measured size of the view. 541 */ 542 private int mMaxSizeSecondary; 543 544 /** 545 * Margin between items. 546 */ 547 private int mHorizontalMargin; 548 /** 549 * Margin between items vertically. 550 */ 551 private int mVerticalMargin; 552 /** 553 * Margin in main direction. 554 */ 555 private int mMarginPrimary; 556 /** 557 * Margin in second direction. 558 */ 559 private int mMarginSecondary; 560 /** 561 * How to position child in secondary direction. 562 */ 563 private int mGravity = Gravity.START | Gravity.TOP; 564 /** 565 * The number of rows in the grid. 566 */ 567 private int mNumRows; 568 /** 569 * Number of rows requested, can be 0 to be determined by parent size and 570 * rowHeight. 571 */ 572 private int mNumRowsRequested = 1; 573 574 /** 575 * Saves grid information of each view. 576 */ 577 Grid mGrid; 578 579 /** 580 * Focus Scroll strategy. 581 */ 582 private int mFocusScrollStrategy = BaseGridView.FOCUS_SCROLL_ALIGNED; 583 /** 584 * Defines how item view is aligned in the window. 585 */ 586 private final WindowAlignment mWindowAlignment = new WindowAlignment(); 587 588 /** 589 * Defines how item view is aligned. 590 */ 591 private final ItemAlignment mItemAlignment = new ItemAlignment(); 592 593 /** 594 * Dimensions of the view, width or height depending on orientation. 595 */ 596 private int mSizePrimary; 597 598 /** 599 * Pixels of extra space for layout item (outside the widget) 600 */ 601 private int mExtraLayoutSpace; 602 603 /** 604 * Allow DPAD key to navigate out at the front of the View (where position = 0), 605 * default is false. 606 */ 607 private boolean mFocusOutFront; 608 609 /** 610 * Allow DPAD key to navigate out at the end of the view, default is false. 611 */ 612 private boolean mFocusOutEnd; 613 614 /** 615 * Allow DPAD key to navigate out of second axis. 616 * default is true. 617 */ 618 private boolean mFocusOutSideStart = true; 619 620 /** 621 * Allow DPAD key to navigate out of second axis. 622 */ 623 private boolean mFocusOutSideEnd = true; 624 625 /** 626 * True if focus search is disabled. 627 */ 628 private boolean mFocusSearchDisabled; 629 630 /** 631 * True if prune child, might be disabled during transition. 632 */ 633 private boolean mPruneChild = true; 634 635 /** 636 * True if scroll content, might be disabled during transition. 637 */ 638 private boolean mScrollEnabled = true; 639 640 /** 641 * Temporary variable: an int array of length=2. 642 */ 643 private static int[] sTwoInts = new int[2]; 644 645 /** 646 * Set to true for RTL layout in horizontal orientation 647 */ 648 private boolean mReverseFlowPrimary = false; 649 650 /** 651 * Set to true for RTL layout in vertical orientation 652 */ 653 private boolean mReverseFlowSecondary = false; 654 655 /** 656 * Temporaries used for measuring. 657 */ 658 private int[] mMeasuredDimension = new int[2]; 659 660 final ViewsStateBundle mChildrenStates = new ViewsStateBundle(); 661 662 /** 663 * Optional interface implemented by Adapter. 664 */ 665 private FacetProviderAdapter mFacetProviderAdapter; 666 667 public GridLayoutManager(BaseGridView baseGridView) { 668 mBaseGridView = baseGridView; 669 } 670 671 public void setOrientation(int orientation) { 672 if (orientation != HORIZONTAL && orientation != VERTICAL) { 673 if (DEBUG) Log.v(getTag(), "invalid orientation: " + orientation); 674 return; 675 } 676 677 mOrientation = orientation; 678 mWindowAlignment.setOrientation(orientation); 679 mItemAlignment.setOrientation(orientation); 680 mForceFullLayout = true; 681 } 682 683 public void onRtlPropertiesChanged(int layoutDirection) { 684 if (mOrientation == HORIZONTAL) { 685 mReverseFlowPrimary = layoutDirection == View.LAYOUT_DIRECTION_RTL; 686 mReverseFlowSecondary = false; 687 } else { 688 mReverseFlowSecondary = layoutDirection == View.LAYOUT_DIRECTION_RTL; 689 mReverseFlowPrimary = false; 690 } 691 mWindowAlignment.horizontal.setReversedFlow(layoutDirection == View.LAYOUT_DIRECTION_RTL); 692 } 693 694 public int getFocusScrollStrategy() { 695 return mFocusScrollStrategy; 696 } 697 698 public void setFocusScrollStrategy(int focusScrollStrategy) { 699 mFocusScrollStrategy = focusScrollStrategy; 700 } 701 702 public void setWindowAlignment(int windowAlignment) { 703 mWindowAlignment.mainAxis().setWindowAlignment(windowAlignment); 704 } 705 706 public int getWindowAlignment() { 707 return mWindowAlignment.mainAxis().getWindowAlignment(); 708 } 709 710 public void setWindowAlignmentOffset(int alignmentOffset) { 711 mWindowAlignment.mainAxis().setWindowAlignmentOffset(alignmentOffset); 712 } 713 714 public int getWindowAlignmentOffset() { 715 return mWindowAlignment.mainAxis().getWindowAlignmentOffset(); 716 } 717 718 public void setWindowAlignmentOffsetPercent(float offsetPercent) { 719 mWindowAlignment.mainAxis().setWindowAlignmentOffsetPercent(offsetPercent); 720 } 721 722 public float getWindowAlignmentOffsetPercent() { 723 return mWindowAlignment.mainAxis().getWindowAlignmentOffsetPercent(); 724 } 725 726 public void setItemAlignmentOffset(int alignmentOffset) { 727 mItemAlignment.mainAxis().setItemAlignmentOffset(alignmentOffset); 728 updateChildAlignments(); 729 } 730 731 public int getItemAlignmentOffset() { 732 return mItemAlignment.mainAxis().getItemAlignmentOffset(); 733 } 734 735 public void setItemAlignmentOffsetWithPadding(boolean withPadding) { 736 mItemAlignment.mainAxis().setItemAlignmentOffsetWithPadding(withPadding); 737 updateChildAlignments(); 738 } 739 740 public boolean isItemAlignmentOffsetWithPadding() { 741 return mItemAlignment.mainAxis().isItemAlignmentOffsetWithPadding(); 742 } 743 744 public void setItemAlignmentOffsetPercent(float offsetPercent) { 745 mItemAlignment.mainAxis().setItemAlignmentOffsetPercent(offsetPercent); 746 updateChildAlignments(); 747 } 748 749 public float getItemAlignmentOffsetPercent() { 750 return mItemAlignment.mainAxis().getItemAlignmentOffsetPercent(); 751 } 752 753 public void setItemAlignmentViewId(int viewId) { 754 mItemAlignment.mainAxis().setItemAlignmentViewId(viewId); 755 updateChildAlignments(); 756 } 757 758 public int getItemAlignmentViewId() { 759 return mItemAlignment.mainAxis().getItemAlignmentViewId(); 760 } 761 762 public void setFocusOutAllowed(boolean throughFront, boolean throughEnd) { 763 mFocusOutFront = throughFront; 764 mFocusOutEnd = throughEnd; 765 } 766 767 public void setFocusOutSideAllowed(boolean throughStart, boolean throughEnd) { 768 mFocusOutSideStart = throughStart; 769 mFocusOutSideEnd = throughEnd; 770 } 771 772 public void setNumRows(int numRows) { 773 if (numRows < 0) throw new IllegalArgumentException(); 774 mNumRowsRequested = numRows; 775 } 776 777 /** 778 * Set the row height. May be WRAP_CONTENT, or a size in pixels. 779 */ 780 public void setRowHeight(int height) { 781 if (height >= 0 || height == ViewGroup.LayoutParams.WRAP_CONTENT) { 782 mRowSizeSecondaryRequested = height; 783 } else { 784 throw new IllegalArgumentException("Invalid row height: " + height); 785 } 786 } 787 788 public void setItemMargin(int margin) { 789 mVerticalMargin = mHorizontalMargin = margin; 790 mMarginPrimary = mMarginSecondary = margin; 791 } 792 793 public void setVerticalMargin(int margin) { 794 if (mOrientation == HORIZONTAL) { 795 mMarginSecondary = mVerticalMargin = margin; 796 } else { 797 mMarginPrimary = mVerticalMargin = margin; 798 } 799 } 800 801 public void setHorizontalMargin(int margin) { 802 if (mOrientation == HORIZONTAL) { 803 mMarginPrimary = mHorizontalMargin = margin; 804 } else { 805 mMarginSecondary = mHorizontalMargin = margin; 806 } 807 } 808 809 public int getVerticalMargin() { 810 return mVerticalMargin; 811 } 812 813 public int getHorizontalMargin() { 814 return mHorizontalMargin; 815 } 816 817 public void setGravity(int gravity) { 818 mGravity = gravity; 819 } 820 821 protected boolean hasDoneFirstLayout() { 822 return mGrid != null; 823 } 824 825 public void setOnChildSelectedListener(OnChildSelectedListener listener) { 826 mChildSelectedListener = listener; 827 } 828 829 public void setOnChildViewHolderSelectedListener(OnChildViewHolderSelectedListener listener) { 830 if (listener == null) { 831 mChildViewHolderSelectedListeners = null; 832 return; 833 } 834 if (mChildViewHolderSelectedListeners == null) { 835 mChildViewHolderSelectedListeners = new ArrayList<OnChildViewHolderSelectedListener>(); 836 } else { 837 mChildViewHolderSelectedListeners.clear(); 838 } 839 mChildViewHolderSelectedListeners.add(listener); 840 } 841 842 public void addOnChildViewHolderSelectedListener(OnChildViewHolderSelectedListener listener) { 843 if (mChildViewHolderSelectedListeners == null) { 844 mChildViewHolderSelectedListeners = new ArrayList<OnChildViewHolderSelectedListener>(); 845 } 846 mChildViewHolderSelectedListeners.add(listener); 847 } 848 849 public void removeOnChildViewHolderSelectedListener(OnChildViewHolderSelectedListener 850 listener) { 851 if (mChildViewHolderSelectedListeners != null) { 852 mChildViewHolderSelectedListeners.remove(listener); 853 } 854 } 855 856 boolean hasOnChildViewHolderSelectedListener() { 857 return mChildViewHolderSelectedListeners != null && 858 mChildViewHolderSelectedListeners.size() > 0; 859 } 860 861 void fireOnChildViewHolderSelected(RecyclerView parent, RecyclerView.ViewHolder child, 862 int position, int subposition) { 863 if (mChildViewHolderSelectedListeners == null) { 864 return; 865 } 866 for (int i = mChildViewHolderSelectedListeners.size() - 1; i >= 0 ; i--) { 867 mChildViewHolderSelectedListeners.get(i).onChildViewHolderSelected(parent, child, 868 position, subposition); 869 } 870 } 871 872 void setOnChildLaidOutListener(OnChildLaidOutListener listener) { 873 mChildLaidOutListener = listener; 874 } 875 876 private int getPositionByView(View view) { 877 if (view == null) { 878 return NO_POSITION; 879 } 880 LayoutParams params = (LayoutParams) view.getLayoutParams(); 881 if (params == null || params.isItemRemoved()) { 882 // when item is removed, the position value can be any value. 883 return NO_POSITION; 884 } 885 return params.getViewPosition(); 886 } 887 888 private int getSubPositionByView(View view, View childView) { 889 if (view == null || childView == null) { 890 return 0; 891 } 892 final LayoutParams lp = (LayoutParams) view.getLayoutParams(); 893 final ItemAlignmentFacet facet = lp.getItemAlignmentFacet(); 894 if (facet != null) { 895 final ItemAlignmentFacet.ItemAlignmentDef[] defs = facet.getAlignmentDefs(); 896 if (defs.length > 1) { 897 while (childView != view) { 898 int id = childView.getId(); 899 if (id != View.NO_ID) { 900 for (int i = 1; i < defs.length; i++) { 901 if (defs[i].getItemAlignmentFocusViewId() == id) { 902 return i; 903 } 904 } 905 } 906 childView = (View) childView.getParent(); 907 } 908 } 909 } 910 return 0; 911 } 912 913 private int getPositionByIndex(int index) { 914 return getPositionByView(getChildAt(index)); 915 } 916 917 private void dispatchChildSelected() { 918 if (mChildSelectedListener == null && !hasOnChildViewHolderSelectedListener()) { 919 return; 920 } 921 922 if (TRACE) TraceHelper.beginSection("onChildSelected"); 923 View view = mFocusPosition == NO_POSITION ? null : findViewByPosition(mFocusPosition); 924 if (view != null) { 925 RecyclerView.ViewHolder vh = mBaseGridView.getChildViewHolder(view); 926 if (mChildSelectedListener != null) { 927 mChildSelectedListener.onChildSelected(mBaseGridView, view, mFocusPosition, 928 vh == null? NO_ID: vh.getItemId()); 929 } 930 fireOnChildViewHolderSelected(mBaseGridView, vh, mFocusPosition, mSubFocusPosition); 931 } else { 932 if (mChildSelectedListener != null) { 933 mChildSelectedListener.onChildSelected(mBaseGridView, null, NO_POSITION, NO_ID); 934 } 935 fireOnChildViewHolderSelected(mBaseGridView, null, NO_POSITION, 0); 936 } 937 if (TRACE) TraceHelper.endSection(); 938 939 // Children may request layout when a child selection event occurs (such as a change of 940 // padding on the current and previously selected rows). 941 // If in layout, a child requesting layout may have been laid out before the selection 942 // callback. 943 // If it was not, the child will be laid out after the selection callback. 944 // If so, the layout request will be honoured though the view system will emit a double- 945 // layout warning. 946 // If not in layout, we may be scrolling in which case the child layout request will be 947 // eaten by recyclerview. Post a requestLayout. 948 if (!mInLayout && !mBaseGridView.isLayoutRequested()) { 949 int childCount = getChildCount(); 950 for (int i = 0; i < childCount; i++) { 951 if (getChildAt(i).isLayoutRequested()) { 952 forceRequestLayout(); 953 break; 954 } 955 } 956 } 957 } 958 959 @Override 960 public boolean canScrollHorizontally() { 961 // We can scroll horizontally if we have horizontal orientation, or if 962 // we are vertical and have more than one column. 963 return mOrientation == HORIZONTAL || mNumRows > 1; 964 } 965 966 @Override 967 public boolean canScrollVertically() { 968 // We can scroll vertically if we have vertical orientation, or if we 969 // are horizontal and have more than one row. 970 return mOrientation == VERTICAL || mNumRows > 1; 971 } 972 973 @Override 974 public RecyclerView.LayoutParams generateDefaultLayoutParams() { 975 return new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, 976 ViewGroup.LayoutParams.WRAP_CONTENT); 977 } 978 979 @Override 980 public RecyclerView.LayoutParams generateLayoutParams(Context context, AttributeSet attrs) { 981 return new LayoutParams(context, attrs); 982 } 983 984 @Override 985 public RecyclerView.LayoutParams generateLayoutParams(ViewGroup.LayoutParams lp) { 986 if (lp instanceof LayoutParams) { 987 return new LayoutParams((LayoutParams) lp); 988 } else if (lp instanceof RecyclerView.LayoutParams) { 989 return new LayoutParams((RecyclerView.LayoutParams) lp); 990 } else if (lp instanceof MarginLayoutParams) { 991 return new LayoutParams((MarginLayoutParams) lp); 992 } else { 993 return new LayoutParams(lp); 994 } 995 } 996 997 protected View getViewForPosition(int position) { 998 return mRecycler.getViewForPosition(position); 999 } 1000 1001 final int getOpticalLeft(View v) { 1002 return ((LayoutParams) v.getLayoutParams()).getOpticalLeft(v); 1003 } 1004 1005 final int getOpticalRight(View v) { 1006 return ((LayoutParams) v.getLayoutParams()).getOpticalRight(v); 1007 } 1008 1009 final int getOpticalTop(View v) { 1010 return ((LayoutParams) v.getLayoutParams()).getOpticalTop(v); 1011 } 1012 1013 final int getOpticalBottom(View v) { 1014 return ((LayoutParams) v.getLayoutParams()).getOpticalBottom(v); 1015 } 1016 1017 private int getViewMin(View v) { 1018 LayoutParams lp = (LayoutParams) v.getLayoutParams(); 1019 return (mOrientation == HORIZONTAL) ? lp.getDecoratedOpticalLeftWithMargin(this, v) 1020 : lp.getDecoratedOpticalTopWithMargin(this, v); 1021 } 1022 1023 private int getViewMax(View v) { 1024 LayoutParams lp = (LayoutParams) v.getLayoutParams(); 1025 return (mOrientation == HORIZONTAL) ? lp.getDecoratedOpticalRightWithMargin(this, v) 1026 : lp.getDecoratedOpticalBottomWithMargin(this, v); 1027 } 1028 1029 private int getViewPrimarySize(View view) { 1030 LayoutParams p = (LayoutParams) view.getLayoutParams(); 1031 return mOrientation == HORIZONTAL ? p.getDecoratedOpticalWidthWithMargin(this, view) 1032 : p.getDecoratedOpticalHeightWithMargin(this, view); 1033 } 1034 1035 private int getViewCenter(View view) { 1036 return (mOrientation == HORIZONTAL) ? getViewCenterX(view) : getViewCenterY(view); 1037 } 1038 1039 private int getViewCenterSecondary(View view) { 1040 return (mOrientation == HORIZONTAL) ? getViewCenterY(view) : getViewCenterX(view); 1041 } 1042 1043 private int getViewCenterX(View v) { 1044 LayoutParams p = (LayoutParams) v.getLayoutParams(); 1045 return p.getOpticalLeft(v) + p.getAlignX(); 1046 } 1047 1048 private int getViewCenterY(View v) { 1049 LayoutParams p = (LayoutParams) v.getLayoutParams(); 1050 return p.getOpticalTop(v) + p.getAlignY(); 1051 } 1052 1053 /** 1054 * Save Recycler and State for convenience. Must be paired with leaveContext(). 1055 */ 1056 private void saveContext(Recycler recycler, State state) { 1057 if (mRecycler != null || mState != null) { 1058 Log.e(TAG, "Recycler information was not released, bug!"); 1059 } 1060 mRecycler = recycler; 1061 mState = state; 1062 } 1063 1064 /** 1065 * Discard saved Recycler and State. 1066 */ 1067 private void leaveContext() { 1068 mRecycler = null; 1069 mState = null; 1070 } 1071 1072 /** 1073 * Re-initialize data structures for a data change or handling invisible 1074 * selection. The method tries its best to preserve position information so 1075 * that staggered grid looks same before and after re-initialize. 1076 * @return true if can fastRelayout() 1077 */ 1078 private boolean layoutInit() { 1079 boolean focusViewWasInTree = mGrid != null && mFocusPosition >= 0 1080 && mFocusPosition >= mGrid.getFirstVisibleIndex() 1081 && mFocusPosition <= mGrid.getLastVisibleIndex(); 1082 final int newItemCount = mState.getItemCount(); 1083 if (newItemCount == 0) { 1084 mFocusPosition = NO_POSITION; 1085 mSubFocusPosition = 0; 1086 } else if (mFocusPosition >= newItemCount) { 1087 mFocusPosition = newItemCount - 1; 1088 mSubFocusPosition = 0; 1089 } else if (mFocusPosition == NO_POSITION && newItemCount > 0) { 1090 // if focus position is never set before, initialize it to 0 1091 mFocusPosition = 0; 1092 mSubFocusPosition = 0; 1093 } 1094 if (!mState.didStructureChange() && mGrid.getFirstVisibleIndex() >= 0 && 1095 !mForceFullLayout && mGrid != null && mGrid.getNumRows() == mNumRows) { 1096 updateScrollController(); 1097 updateScrollSecondAxis(); 1098 mGrid.setMargin(mMarginPrimary); 1099 if (!focusViewWasInTree && mFocusPosition != NO_POSITION) { 1100 mGrid.setStart(mFocusPosition); 1101 } 1102 return true; 1103 } else { 1104 mForceFullLayout = false; 1105 int firstVisibleIndex = focusViewWasInTree ? mGrid.getFirstVisibleIndex() : 0; 1106 1107 if (mGrid == null || mNumRows != mGrid.getNumRows() || 1108 mReverseFlowPrimary != mGrid.isReversedFlow()) { 1109 mGrid = Grid.createGrid(mNumRows); 1110 mGrid.setProvider(mGridProvider); 1111 mGrid.setReversedFlow(mReverseFlowPrimary); 1112 } 1113 initScrollController(); 1114 updateScrollSecondAxis(); 1115 mGrid.setMargin(mMarginPrimary); 1116 detachAndScrapAttachedViews(mRecycler); 1117 mGrid.resetVisibleIndex(); 1118 if (mFocusPosition == NO_POSITION) { 1119 mBaseGridView.clearFocus(); 1120 } 1121 mWindowAlignment.mainAxis().invalidateScrollMin(); 1122 mWindowAlignment.mainAxis().invalidateScrollMax(); 1123 if (focusViewWasInTree && firstVisibleIndex <= mFocusPosition) { 1124 // if focusView was in tree, we will add item from first visible item 1125 mGrid.setStart(firstVisibleIndex); 1126 } else { 1127 // if focusView was not in tree, it's probably because focus position jumped 1128 // far away from visible range, so use mFocusPosition as start 1129 mGrid.setStart(mFocusPosition); 1130 } 1131 return false; 1132 } 1133 } 1134 1135 private int getRowSizeSecondary(int rowIndex) { 1136 if (mFixedRowSizeSecondary != 0) { 1137 return mFixedRowSizeSecondary; 1138 } 1139 if (mRowSizeSecondary == null) { 1140 return 0; 1141 } 1142 return mRowSizeSecondary[rowIndex]; 1143 } 1144 1145 private int getRowStartSecondary(int rowIndex) { 1146 int start = 0; 1147 // Iterate from left to right, which is a different index traversal 1148 // in RTL flow 1149 if (mReverseFlowSecondary) { 1150 for (int i = mNumRows-1; i > rowIndex; i--) { 1151 start += getRowSizeSecondary(i) + mMarginSecondary; 1152 } 1153 } else { 1154 for (int i = 0; i < rowIndex; i++) { 1155 start += getRowSizeSecondary(i) + mMarginSecondary; 1156 } 1157 } 1158 return start; 1159 } 1160 1161 private int getSizeSecondary() { 1162 int rightmostIndex = mReverseFlowSecondary ? 0 : mNumRows - 1; 1163 return getRowStartSecondary(rightmostIndex) + getRowSizeSecondary(rightmostIndex); 1164 } 1165 1166 int getDecoratedMeasuredWidthWithMargin(View v) { 1167 final LayoutParams lp = (LayoutParams) v.getLayoutParams(); 1168 return getDecoratedMeasuredWidth(v) + lp.leftMargin + lp.rightMargin; 1169 } 1170 1171 int getDecoratedMeasuredHeightWithMargin(View v) { 1172 final LayoutParams lp = (LayoutParams) v.getLayoutParams(); 1173 return getDecoratedMeasuredHeight(v) + lp.topMargin + lp.bottomMargin; 1174 } 1175 1176 private void measureScrapChild(int position, int widthSpec, int heightSpec, 1177 int[] measuredDimension) { 1178 View view = mRecycler.getViewForPosition(position); 1179 if (view != null) { 1180 final LayoutParams p = (LayoutParams) view.getLayoutParams(); 1181 calculateItemDecorationsForChild(view, sTempRect); 1182 int widthUsed = p.leftMargin + p.rightMargin + sTempRect.left + sTempRect.right; 1183 int heightUsed = p.topMargin + p.bottomMargin + sTempRect.top + sTempRect.bottom; 1184 1185 int childWidthSpec = ViewGroup.getChildMeasureSpec(widthSpec, 1186 getPaddingLeft() + getPaddingRight() + widthUsed, p.width); 1187 int childHeightSpec = ViewGroup.getChildMeasureSpec(heightSpec, 1188 getPaddingTop() + getPaddingBottom() + heightUsed, p.height); 1189 view.measure(childWidthSpec, childHeightSpec); 1190 1191 measuredDimension[0] = getDecoratedMeasuredWidthWithMargin(view); 1192 measuredDimension[1] = getDecoratedMeasuredHeightWithMargin(view); 1193 mRecycler.recycleView(view); 1194 } 1195 } 1196 1197 private boolean processRowSizeSecondary(boolean measure) { 1198 if (mFixedRowSizeSecondary != 0 || mRowSizeSecondary == null) { 1199 return false; 1200 } 1201 1202 if (TRACE) TraceHelper.beginSection("processRowSizeSecondary"); 1203 CircularIntArray[] rows = mGrid == null ? null : mGrid.getItemPositionsInRows(); 1204 boolean changed = false; 1205 int scrapChildWidth = -1; 1206 int scrapChildHeight = -1; 1207 1208 for (int rowIndex = 0; rowIndex < mNumRows; rowIndex++) { 1209 CircularIntArray row = rows == null ? null : rows[rowIndex]; 1210 final int rowItemsPairCount = row == null ? 0 : row.size(); 1211 int rowSize = -1; 1212 for (int rowItemPairIndex = 0; rowItemPairIndex < rowItemsPairCount; 1213 rowItemPairIndex += 2) { 1214 final int rowIndexStart = row.get(rowItemPairIndex); 1215 final int rowIndexEnd = row.get(rowItemPairIndex + 1); 1216 for (int i = rowIndexStart; i <= rowIndexEnd; i++) { 1217 final View view = findViewByPosition(i); 1218 if (view == null) { 1219 continue; 1220 } 1221 if (measure && view.isLayoutRequested()) { 1222 measureChild(view); 1223 } 1224 final int secondarySize = mOrientation == HORIZONTAL ? 1225 getDecoratedMeasuredHeightWithMargin(view) 1226 : getDecoratedMeasuredWidthWithMargin(view); 1227 if (secondarySize > rowSize) { 1228 rowSize = secondarySize; 1229 } 1230 } 1231 } 1232 1233 final int itemCount = mState.getItemCount(); 1234 if (!mBaseGridView.hasFixedSize() && measure && rowSize < 0 && itemCount > 0) { 1235 if (scrapChildWidth < 0 && scrapChildHeight < 0) { 1236 int position; 1237 if (mFocusPosition == NO_POSITION) { 1238 position = 0; 1239 } else if (mFocusPosition >= itemCount) { 1240 position = itemCount - 1; 1241 } else { 1242 position = mFocusPosition; 1243 } 1244 measureScrapChild(position, 1245 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), 1246 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), 1247 mMeasuredDimension); 1248 scrapChildWidth = mMeasuredDimension[0]; 1249 scrapChildHeight = mMeasuredDimension[1]; 1250 if (DEBUG) Log.v(TAG, "measured scrap child: " + scrapChildWidth + 1251 " " + scrapChildHeight); 1252 } 1253 rowSize = mOrientation == HORIZONTAL ? scrapChildHeight : scrapChildWidth; 1254 } 1255 if (rowSize < 0) { 1256 rowSize = 0; 1257 } 1258 if (mRowSizeSecondary[rowIndex] != rowSize) { 1259 if (DEBUG) Log.v(getTag(), "row size secondary changed: " + mRowSizeSecondary[rowIndex] + 1260 ", " + rowSize); 1261 mRowSizeSecondary[rowIndex] = rowSize; 1262 changed = true; 1263 } 1264 } 1265 1266 if (TRACE) TraceHelper.endSection(); 1267 return changed; 1268 } 1269 1270 /** 1271 * Checks if we need to update row secondary sizes. 1272 */ 1273 private void updateRowSecondarySizeRefresh() { 1274 mRowSecondarySizeRefresh = processRowSizeSecondary(false); 1275 if (mRowSecondarySizeRefresh) { 1276 if (DEBUG) Log.v(getTag(), "mRowSecondarySizeRefresh now set"); 1277 forceRequestLayout(); 1278 } 1279 } 1280 1281 private void forceRequestLayout() { 1282 if (DEBUG) Log.v(getTag(), "forceRequestLayout"); 1283 // RecyclerView prevents us from requesting layout in many cases 1284 // (during layout, during scroll, etc.) 1285 // For secondary row size wrap_content support we currently need a 1286 // second layout pass to update the measured size after having measured 1287 // and added child views in layoutChildren. 1288 // Force the second layout by posting a delayed runnable. 1289 // TODO: investigate allowing a second layout pass, 1290 // or move child add/measure logic to the measure phase. 1291 ViewCompat.postOnAnimation(mBaseGridView, mRequestLayoutRunnable); 1292 } 1293 1294 private final Runnable mRequestLayoutRunnable = new Runnable() { 1295 @Override 1296 public void run() { 1297 if (DEBUG) Log.v(getTag(), "request Layout from runnable"); 1298 requestLayout(); 1299 } 1300 }; 1301 1302 @Override 1303 public void onMeasure(Recycler recycler, State state, int widthSpec, int heightSpec) { 1304 saveContext(recycler, state); 1305 1306 int sizePrimary, sizeSecondary, modeSecondary, paddingSecondary; 1307 int measuredSizeSecondary; 1308 if (mOrientation == HORIZONTAL) { 1309 sizePrimary = MeasureSpec.getSize(widthSpec); 1310 sizeSecondary = MeasureSpec.getSize(heightSpec); 1311 modeSecondary = MeasureSpec.getMode(heightSpec); 1312 paddingSecondary = getPaddingTop() + getPaddingBottom(); 1313 } else { 1314 sizeSecondary = MeasureSpec.getSize(widthSpec); 1315 sizePrimary = MeasureSpec.getSize(heightSpec); 1316 modeSecondary = MeasureSpec.getMode(widthSpec); 1317 paddingSecondary = getPaddingLeft() + getPaddingRight(); 1318 } 1319 if (DEBUG) Log.v(getTag(), "onMeasure widthSpec " + Integer.toHexString(widthSpec) + 1320 " heightSpec " + Integer.toHexString(heightSpec) + 1321 " modeSecondary " + Integer.toHexString(modeSecondary) + 1322 " sizeSecondary " + sizeSecondary + " " + this); 1323 1324 mMaxSizeSecondary = sizeSecondary; 1325 1326 if (mRowSizeSecondaryRequested == ViewGroup.LayoutParams.WRAP_CONTENT) { 1327 mNumRows = mNumRowsRequested == 0 ? 1 : mNumRowsRequested; 1328 mFixedRowSizeSecondary = 0; 1329 1330 if (mRowSizeSecondary == null || mRowSizeSecondary.length != mNumRows) { 1331 mRowSizeSecondary = new int[mNumRows]; 1332 } 1333 1334 // Measure all current children and update cached row heights 1335 processRowSizeSecondary(true); 1336 1337 switch (modeSecondary) { 1338 case MeasureSpec.UNSPECIFIED: 1339 measuredSizeSecondary = getSizeSecondary() + paddingSecondary; 1340 break; 1341 case MeasureSpec.AT_MOST: 1342 measuredSizeSecondary = Math.min(getSizeSecondary() + paddingSecondary, 1343 mMaxSizeSecondary); 1344 break; 1345 case MeasureSpec.EXACTLY: 1346 measuredSizeSecondary = mMaxSizeSecondary; 1347 break; 1348 default: 1349 throw new IllegalStateException("wrong spec"); 1350 } 1351 1352 } else { 1353 switch (modeSecondary) { 1354 case MeasureSpec.UNSPECIFIED: 1355 mFixedRowSizeSecondary = mRowSizeSecondaryRequested == 0 ? 1356 sizeSecondary - paddingSecondary: mRowSizeSecondaryRequested; 1357 mNumRows = mNumRowsRequested == 0 ? 1 : mNumRowsRequested; 1358 measuredSizeSecondary = mFixedRowSizeSecondary * mNumRows + mMarginSecondary 1359 * (mNumRows - 1) + paddingSecondary; 1360 break; 1361 case MeasureSpec.AT_MOST: 1362 case MeasureSpec.EXACTLY: 1363 if (mNumRowsRequested == 0 && mRowSizeSecondaryRequested == 0) { 1364 mNumRows = 1; 1365 mFixedRowSizeSecondary = sizeSecondary - paddingSecondary; 1366 } else if (mNumRowsRequested == 0) { 1367 mFixedRowSizeSecondary = mRowSizeSecondaryRequested; 1368 mNumRows = (sizeSecondary + mMarginSecondary) 1369 / (mRowSizeSecondaryRequested + mMarginSecondary); 1370 } else if (mRowSizeSecondaryRequested == 0) { 1371 mNumRows = mNumRowsRequested; 1372 mFixedRowSizeSecondary = (sizeSecondary - paddingSecondary - mMarginSecondary 1373 * (mNumRows - 1)) / mNumRows; 1374 } else { 1375 mNumRows = mNumRowsRequested; 1376 mFixedRowSizeSecondary = mRowSizeSecondaryRequested; 1377 } 1378 measuredSizeSecondary = sizeSecondary; 1379 if (modeSecondary == MeasureSpec.AT_MOST) { 1380 int childrenSize = mFixedRowSizeSecondary * mNumRows + mMarginSecondary 1381 * (mNumRows - 1) + paddingSecondary; 1382 if (childrenSize < measuredSizeSecondary) { 1383 measuredSizeSecondary = childrenSize; 1384 } 1385 } 1386 break; 1387 default: 1388 throw new IllegalStateException("wrong spec"); 1389 } 1390 } 1391 if (mOrientation == HORIZONTAL) { 1392 setMeasuredDimension(sizePrimary, measuredSizeSecondary); 1393 } else { 1394 setMeasuredDimension(measuredSizeSecondary, sizePrimary); 1395 } 1396 if (DEBUG) { 1397 Log.v(getTag(), "onMeasure sizePrimary " + sizePrimary + 1398 " measuredSizeSecondary " + measuredSizeSecondary + 1399 " mFixedRowSizeSecondary " + mFixedRowSizeSecondary + 1400 " mNumRows " + mNumRows); 1401 } 1402 leaveContext(); 1403 } 1404 1405 private void measureChild(View child) { 1406 if (TRACE) TraceHelper.beginSection("measureChild"); 1407 final LayoutParams lp = (LayoutParams) child.getLayoutParams(); 1408 calculateItemDecorationsForChild(child, sTempRect); 1409 int widthUsed = lp.leftMargin + lp.rightMargin + sTempRect.left + sTempRect.right; 1410 int heightUsed = lp.topMargin + lp.bottomMargin + sTempRect.top + sTempRect.bottom; 1411 1412 final int secondarySpec = (mRowSizeSecondaryRequested == ViewGroup.LayoutParams.WRAP_CONTENT) ? 1413 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED) : 1414 MeasureSpec.makeMeasureSpec(mFixedRowSizeSecondary, MeasureSpec.EXACTLY); 1415 int widthSpec, heightSpec; 1416 1417 if (mOrientation == HORIZONTAL) { 1418 widthSpec = ViewGroup.getChildMeasureSpec( 1419 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), widthUsed, lp.width); 1420 heightSpec = ViewGroup.getChildMeasureSpec(secondarySpec, heightUsed, lp.height); 1421 } else { 1422 heightSpec = ViewGroup.getChildMeasureSpec( 1423 MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED), heightUsed, lp.height); 1424 widthSpec = ViewGroup.getChildMeasureSpec(secondarySpec, widthUsed, lp.width); 1425 } 1426 child.measure(widthSpec, heightSpec); 1427 if (DEBUG) Log.v(getTag(), "measureChild secondarySpec " + Integer.toHexString(secondarySpec) + 1428 " widthSpec " + Integer.toHexString(widthSpec) + 1429 " heightSpec " + Integer.toHexString(heightSpec) + 1430 " measuredWidth " + child.getMeasuredWidth() + 1431 " measuredHeight " + child.getMeasuredHeight()); 1432 if (DEBUG) Log.v(getTag(), "child lp width " + lp.width + " height " + lp.height); 1433 if (TRACE) TraceHelper.endSection(); 1434 } 1435 1436 /** 1437 * Get facet from the ViewHolder or the viewType. 1438 */ 1439 private <E> E getFacet(RecyclerView.ViewHolder vh, Class<? extends E> facetClass) { 1440 E facet = null; 1441 if (vh instanceof FacetProvider) { 1442 facet = (E) ((FacetProvider) vh).getFacet(facetClass); 1443 } 1444 if (facet == null && mFacetProviderAdapter != null) { 1445 FacetProvider p = mFacetProviderAdapter.getFacetProvider(vh.getItemViewType()); 1446 if (p != null) { 1447 facet = (E) p.getFacet(facetClass); 1448 } 1449 } 1450 return facet; 1451 } 1452 1453 private Grid.Provider mGridProvider = new Grid.Provider() { 1454 1455 @Override 1456 public int getCount() { 1457 return mState.getItemCount(); 1458 } 1459 1460 @Override 1461 public int createItem(int index, boolean append, Object[] item) { 1462 if (TRACE) TraceHelper.beginSection("createItem"); 1463 if (TRACE) TraceHelper.beginSection("getview"); 1464 View v = getViewForPosition(index); 1465 if (TRACE) TraceHelper.endSection(); 1466 LayoutParams lp = (LayoutParams) v.getLayoutParams(); 1467 RecyclerView.ViewHolder vh = mBaseGridView.getChildViewHolder(v); 1468 lp.setItemAlignmentFacet((ItemAlignmentFacet)getFacet(vh, ItemAlignmentFacet.class)); 1469 // See recyclerView docs: we don't need re-add scraped view if it was removed. 1470 if (!lp.isItemRemoved()) { 1471 if (TRACE) TraceHelper.beginSection("addView"); 1472 if (append) { 1473 addView(v); 1474 } else { 1475 addView(v, 0); 1476 } 1477 if (TRACE) TraceHelper.endSection(); 1478 if (mChildVisibility != -1) { 1479 v.setVisibility(mChildVisibility); 1480 } 1481 1482 if (mPendingMoveSmoothScroller != null) { 1483 mPendingMoveSmoothScroller.consumePendingMovesBeforeLayout(); 1484 } 1485 int subindex = getSubPositionByView(v, v.findFocus()); 1486 if (!mInLayout) { 1487 // when we are appending item during scroll pass and the item's position 1488 // matches the mFocusPosition, we should signal a childSelected event. 1489 // However if we are still running PendingMoveSmoothScroller, we defer and 1490 // signal the event in PendingMoveSmoothScroller.onStop(). This can 1491 // avoid lots of childSelected events during a long smooth scrolling and 1492 // increase performance. 1493 if (index == mFocusPosition && subindex == mSubFocusPosition 1494 && mPendingMoveSmoothScroller == null) { 1495 dispatchChildSelected(); 1496 } 1497 } else if (!mInFastRelayout) { 1498 // fastRelayout will dispatch event at end of onLayoutChildren(). 1499 // For full layout, two situations here: 1500 // 1. mInLayoutSearchFocus is false, dispatchChildSelected() at mFocusPosition. 1501 // 2. mInLayoutSearchFocus is true: dispatchChildSelected() on first child 1502 // equal to or after mFocusPosition that can take focus. 1503 if (!mInLayoutSearchFocus && index == mFocusPosition 1504 && subindex == mSubFocusPosition) { 1505 dispatchChildSelected(); 1506 } else if (mInLayoutSearchFocus && index >= mFocusPosition 1507 && v.hasFocusable()) { 1508 mFocusPosition = index; 1509 mSubFocusPosition = subindex; 1510 mInLayoutSearchFocus = false; 1511 dispatchChildSelected(); 1512 } 1513 } 1514 measureChild(v); 1515 } 1516 item[0] = v; 1517 return mOrientation == HORIZONTAL ? getDecoratedMeasuredWidthWithMargin(v) 1518 : getDecoratedMeasuredHeightWithMargin(v); 1519 } 1520 1521 @Override 1522 public void addItem(Object item, int index, int length, int rowIndex, int edge) { 1523 View v = (View) item; 1524 int start, end; 1525 if (edge == Integer.MIN_VALUE || edge == Integer.MAX_VALUE) { 1526 edge = !mGrid.isReversedFlow() ? mWindowAlignment.mainAxis().getPaddingLow() 1527 : mWindowAlignment.mainAxis().getSize() 1528 - mWindowAlignment.mainAxis().getPaddingHigh(); 1529 } 1530 boolean edgeIsMin = !mGrid.isReversedFlow(); 1531 if (edgeIsMin) { 1532 start = edge; 1533 end = edge + length; 1534 } else { 1535 start = edge - length; 1536 end = edge; 1537 } 1538 int startSecondary = getRowStartSecondary(rowIndex) - mScrollOffsetSecondary; 1539 mChildrenStates.loadView(v, index); 1540 layoutChild(rowIndex, v, start, end, startSecondary); 1541 if (DEBUG) { 1542 Log.d(getTag(), "addView " + index + " " + v); 1543 } 1544 if (TRACE) TraceHelper.endSection(); 1545 1546 if (index == mGrid.getFirstVisibleIndex()) { 1547 if (!mGrid.isReversedFlow()) { 1548 updateScrollMin(); 1549 } else { 1550 updateScrollMax(); 1551 } 1552 } 1553 if (index == mGrid.getLastVisibleIndex()) { 1554 if (!mGrid.isReversedFlow()) { 1555 updateScrollMax(); 1556 } else { 1557 updateScrollMin(); 1558 } 1559 } 1560 if (!mInLayout && mPendingMoveSmoothScroller != null) { 1561 mPendingMoveSmoothScroller.consumePendingMovesAfterLayout(); 1562 } 1563 if (mChildLaidOutListener != null) { 1564 RecyclerView.ViewHolder vh = mBaseGridView.getChildViewHolder(v); 1565 mChildLaidOutListener.onChildLaidOut(mBaseGridView, v, index, 1566 vh == null ? NO_ID : vh.getItemId()); 1567 } 1568 } 1569 1570 @Override 1571 public void removeItem(int index) { 1572 if (TRACE) TraceHelper.beginSection("removeItem"); 1573 View v = findViewByPosition(index); 1574 if (mInLayout) { 1575 detachAndScrapView(v, mRecycler); 1576 } else { 1577 removeAndRecycleView(v, mRecycler); 1578 } 1579 if (TRACE) TraceHelper.endSection(); 1580 } 1581 1582 @Override 1583 public int getEdge(int index) { 1584 if (mReverseFlowPrimary) { 1585 return getViewMax(findViewByPosition(index)); 1586 } else { 1587 return getViewMin(findViewByPosition(index)); 1588 } 1589 } 1590 1591 @Override 1592 public int getSize(int index) { 1593 return getViewPrimarySize(findViewByPosition(index)); 1594 } 1595 }; 1596 1597 private void layoutChild(int rowIndex, View v, int start, int end, int startSecondary) { 1598 if (TRACE) TraceHelper.beginSection("layoutChild"); 1599 int sizeSecondary = mOrientation == HORIZONTAL ? getDecoratedMeasuredHeightWithMargin(v) 1600 : getDecoratedMeasuredWidthWithMargin(v); 1601 if (mFixedRowSizeSecondary > 0) { 1602 sizeSecondary = Math.min(sizeSecondary, mFixedRowSizeSecondary); 1603 } 1604 final int verticalGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK; 1605 final int horizontalGravity = (mReverseFlowPrimary || mReverseFlowSecondary) ? 1606 Gravity.getAbsoluteGravity(mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK, View.LAYOUT_DIRECTION_RTL) : 1607 mGravity & Gravity.HORIZONTAL_GRAVITY_MASK; 1608 if (mOrientation == HORIZONTAL && verticalGravity == Gravity.TOP 1609 || mOrientation == VERTICAL && horizontalGravity == Gravity.LEFT) { 1610 // do nothing 1611 } else if (mOrientation == HORIZONTAL && verticalGravity == Gravity.BOTTOM 1612 || mOrientation == VERTICAL && horizontalGravity == Gravity.RIGHT) { 1613 startSecondary += getRowSizeSecondary(rowIndex) - sizeSecondary; 1614 } else if (mOrientation == HORIZONTAL && verticalGravity == Gravity.CENTER_VERTICAL 1615 || mOrientation == VERTICAL && horizontalGravity == Gravity.CENTER_HORIZONTAL) { 1616 startSecondary += (getRowSizeSecondary(rowIndex) - sizeSecondary) / 2; 1617 } 1618 int left, top, right, bottom; 1619 if (mOrientation == HORIZONTAL) { 1620 left = start; 1621 top = startSecondary; 1622 right = end; 1623 bottom = startSecondary + sizeSecondary; 1624 } else { 1625 top = start; 1626 left = startSecondary; 1627 bottom = end; 1628 right = startSecondary + sizeSecondary; 1629 } 1630 LayoutParams params = (LayoutParams) v.getLayoutParams(); 1631 layoutDecorated(v, left + params.leftMargin, top + params.topMargin, 1632 right - params.rightMargin, bottom - params.bottomMargin); 1633 updateChildOpticalInsets(v, left, top, right, bottom); 1634 updateChildAlignments(v); 1635 if (TRACE) TraceHelper.endSection(); 1636 } 1637 1638 private void updateChildOpticalInsets(View v, int left, int top, int right, int bottom) { 1639 LayoutParams p = (LayoutParams) v.getLayoutParams(); 1640 p.setOpticalInsets(left - v.getLeft(), top - v.getTop(), 1641 v.getRight() - right, v.getBottom() - bottom); 1642 } 1643 1644 private void updateChildAlignments(View v) { 1645 final LayoutParams p = (LayoutParams) v.getLayoutParams(); 1646 if (p.getItemAlignmentFacet() == null) { 1647 // Fallback to global settings on grid view 1648 p.setAlignX(mItemAlignment.horizontal.getAlignmentPosition(v)); 1649 p.setAlignY(mItemAlignment.vertical.getAlignmentPosition(v)); 1650 } else { 1651 // Use ItemAlignmentFacet defined on specific ViewHolder 1652 p.calculateItemAlignments(mOrientation, v); 1653 if (mOrientation == HORIZONTAL) { 1654 p.setAlignY(mItemAlignment.vertical.getAlignmentPosition(v)); 1655 } else { 1656 p.setAlignX(mItemAlignment.horizontal.getAlignmentPosition(v)); 1657 } 1658 } 1659 } 1660 1661 private void updateChildAlignments() { 1662 for (int i = 0, c = getChildCount(); i < c; i++) { 1663 updateChildAlignments(getChildAt(i)); 1664 } 1665 } 1666 1667 void setExtraLayoutSpace(int extraLayoutSpace) { 1668 if (mExtraLayoutSpace == extraLayoutSpace) { 1669 return; 1670 } else if (mExtraLayoutSpace < 0) { 1671 throw new IllegalArgumentException("ExtraLayoutSpace must >= 0"); 1672 } 1673 mExtraLayoutSpace = extraLayoutSpace; 1674 requestLayout(); 1675 } 1676 1677 int getExtraLayoutSpace() { 1678 return mExtraLayoutSpace; 1679 } 1680 1681 private void removeInvisibleViewsAtEnd() { 1682 if (mPruneChild) { 1683 mGrid.removeInvisibleItemsAtEnd(mFocusPosition, 1684 mReverseFlowPrimary ? -mExtraLayoutSpace : mSizePrimary + mExtraLayoutSpace); 1685 } 1686 } 1687 1688 private void removeInvisibleViewsAtFront() { 1689 if (mPruneChild) { 1690 mGrid.removeInvisibleItemsAtFront(mFocusPosition, 1691 mReverseFlowPrimary ? mSizePrimary + mExtraLayoutSpace: -mExtraLayoutSpace); 1692 } 1693 } 1694 1695 private boolean appendOneColumnVisibleItems() { 1696 return mGrid.appendOneColumnVisibleItems(); 1697 } 1698 1699 private boolean prependOneColumnVisibleItems() { 1700 return mGrid.prependOneColumnVisibleItems(); 1701 } 1702 1703 private void appendVisibleItems() { 1704 mGrid.appendVisibleItems(mReverseFlowPrimary ? -mExtraLayoutSpace 1705 : mSizePrimary + mExtraLayoutSpace); 1706 } 1707 1708 private void prependVisibleItems() { 1709 mGrid.prependVisibleItems(mReverseFlowPrimary ? mSizePrimary + mExtraLayoutSpace 1710 : -mExtraLayoutSpace); 1711 } 1712 1713 /** 1714 * Fast layout when there is no structure change, adapter change, etc. 1715 * It will layout all views was layout requested or updated, until hit a view 1716 * with different size, then it break and detachAndScrap all views after that. 1717 */ 1718 private void fastRelayout() { 1719 boolean invalidateAfter = false; 1720 final int childCount = getChildCount(); 1721 int position = -1; 1722 for (int index = 0; index < childCount; index++) { 1723 View view = getChildAt(index); 1724 position = getPositionByIndex(index); 1725 Grid.Location location = mGrid.getLocation(position); 1726 if (location == null) { 1727 if (DEBUG) Log.w(getTag(), "fastRelayout(): no Location at " + position); 1728 invalidateAfter = true; 1729 break; 1730 } 1731 1732 int startSecondary = getRowStartSecondary(location.row) - mScrollOffsetSecondary; 1733 int primarySize, end; 1734 int start = getViewMin(view); 1735 int oldPrimarySize = getViewPrimarySize(view); 1736 1737 LayoutParams lp = (LayoutParams) view.getLayoutParams(); 1738 if (lp.viewNeedsUpdate()) { 1739 int viewIndex = mBaseGridView.indexOfChild(view); 1740 detachAndScrapView(view, mRecycler); 1741 view = getViewForPosition(position); 1742 addView(view, viewIndex); 1743 } 1744 1745 if (view.isLayoutRequested()) { 1746 measureChild(view); 1747 } 1748 if (mOrientation == HORIZONTAL) { 1749 primarySize = getDecoratedMeasuredWidthWithMargin(view); 1750 end = start + primarySize; 1751 } else { 1752 primarySize = getDecoratedMeasuredHeightWithMargin(view); 1753 end = start + primarySize; 1754 } 1755 layoutChild(location.row, view, start, end, startSecondary); 1756 if (oldPrimarySize != primarySize) { 1757 // size changed invalidate remaining Locations 1758 if (DEBUG) Log.d(getTag(), "fastRelayout: view size changed at " + position); 1759 invalidateAfter = true; 1760 break; 1761 } 1762 } 1763 if (invalidateAfter) { 1764 final int savedLastPos = mGrid.getLastVisibleIndex(); 1765 mGrid.invalidateItemsAfter(position); 1766 if (mPruneChild) { 1767 // in regular prune child mode, we just append items up to edge limit 1768 appendVisibleItems(); 1769 if (mFocusPosition >= 0 && mFocusPosition <= savedLastPos) { 1770 // make sure add focus view back: the view might be outside edge limit 1771 // when there is delta in onLayoutChildren(). 1772 while (mGrid.getLastVisibleIndex() < mFocusPosition) { 1773 mGrid.appendOneColumnVisibleItems(); 1774 } 1775 } 1776 } else { 1777 // prune disabled(e.g. in RowsFragment transition): append all removed items 1778 while (mGrid.appendOneColumnVisibleItems() 1779 && mGrid.getLastVisibleIndex() < savedLastPos); 1780 } 1781 } 1782 updateScrollMin(); 1783 updateScrollMax(); 1784 updateScrollSecondAxis(); 1785 } 1786 1787 public void removeAndRecycleAllViews(RecyclerView.Recycler recycler) { 1788 if (TRACE) TraceHelper.beginSection("removeAndRecycleAllViews"); 1789 if (DEBUG) Log.v(TAG, "removeAndRecycleAllViews " + getChildCount()); 1790 for (int i = getChildCount() - 1; i >= 0; i--) { 1791 removeAndRecycleViewAt(i, recycler); 1792 } 1793 if (TRACE) TraceHelper.endSection(); 1794 } 1795 1796 // Lays out items based on the current scroll position 1797 @Override 1798 public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) { 1799 if (DEBUG) { 1800 Log.v(getTag(), "layoutChildren start numRows " + mNumRows + " mScrollOffsetSecondary " 1801 + mScrollOffsetSecondary + " mScrollOffsetPrimary " + mScrollOffsetPrimary 1802 + " inPreLayout " + state.isPreLayout() 1803 + " didStructureChange " + state.didStructureChange() 1804 + " mForceFullLayout " + mForceFullLayout); 1805 Log.v(getTag(), "width " + getWidth() + " height " + getHeight()); 1806 } 1807 1808 if (mNumRows == 0) { 1809 // haven't done measure yet 1810 return; 1811 } 1812 final int itemCount = state.getItemCount(); 1813 if (itemCount < 0) { 1814 return; 1815 } 1816 1817 if (!mLayoutEnabled) { 1818 discardLayoutInfo(); 1819 removeAndRecycleAllViews(recycler); 1820 return; 1821 } 1822 mInLayout = true; 1823 1824 if (state.didStructureChange()) { 1825 // didStructureChange() == true means attached item has been removed/added. 1826 // scroll animation: we are unable to continue a scroll animation, 1827 // kill the scroll animation, and let ItemAnimation move the item to new position. 1828 // position smooth scroller: kill the animation and stop at final position. 1829 // pending smooth scroller: stop and scroll to current focus position. 1830 mBaseGridView.stopScroll(); 1831 } 1832 final boolean scrollToFocus = !isSmoothScrolling() 1833 && mFocusScrollStrategy == BaseGridView.FOCUS_SCROLL_ALIGNED; 1834 if (mFocusPosition != NO_POSITION && mFocusPositionOffset != Integer.MIN_VALUE) { 1835 mFocusPosition = mFocusPosition + mFocusPositionOffset; 1836 mSubFocusPosition = 0; 1837 } 1838 mFocusPositionOffset = 0; 1839 saveContext(recycler, state); 1840 1841 View savedFocusView = findViewByPosition(mFocusPosition); 1842 int savedFocusPos = mFocusPosition; 1843 int savedSubFocusPos = mSubFocusPosition; 1844 boolean hadFocus = mBaseGridView.hasFocus(); 1845 1846 // Track the old focus view so we can adjust our system scroll position 1847 // so that any scroll animations happening now will remain valid. 1848 // We must use same delta in Pre Layout (if prelayout exists) and second layout. 1849 // So we cache the deltas in PreLayout and use it in second layout. 1850 int delta = 0, deltaSecondary = 0; 1851 if (mFocusPosition != NO_POSITION && scrollToFocus 1852 && mBaseGridView.getScrollState() != RecyclerView.SCROLL_STATE_IDLE) { 1853 // FIXME: we should get the remaining scroll animation offset from RecyclerView 1854 if (savedFocusView != null) { 1855 if (getScrollPosition(savedFocusView, savedFocusView.findFocus(), sTwoInts)) { 1856 delta = sTwoInts[0]; 1857 deltaSecondary = sTwoInts[1]; 1858 } 1859 } 1860 } 1861 1862 if (mInFastRelayout = layoutInit()) { 1863 fastRelayout(); 1864 // appends items till focus position. 1865 if (mFocusPosition != NO_POSITION) { 1866 View focusView = findViewByPosition(mFocusPosition); 1867 if (focusView != null) { 1868 if (scrollToFocus) { 1869 scrollToView(focusView, false); 1870 } 1871 if (hadFocus && !focusView.hasFocus()) { 1872 focusView.requestFocus(); 1873 } 1874 } 1875 } 1876 } else { 1877 mInLayoutSearchFocus = hadFocus; 1878 if (mFocusPosition != NO_POSITION) { 1879 // appends items till focus position. 1880 while (appendOneColumnVisibleItems() 1881 && findViewByPosition(mFocusPosition) == null) ; 1882 } 1883 // multiple rounds: scrollToView of first round may drag first/last child into 1884 // "visible window" and we update scrollMin/scrollMax then run second scrollToView 1885 int oldFirstVisible; 1886 int oldLastVisible; 1887 do { 1888 updateScrollMin(); 1889 updateScrollMax(); 1890 oldFirstVisible = mGrid.getFirstVisibleIndex(); 1891 oldLastVisible = mGrid.getLastVisibleIndex(); 1892 View focusView = findViewByPosition(mFocusPosition); 1893 // we need force to initialize the child view's position 1894 scrollToView(focusView, false); 1895 if (focusView != null && hadFocus && !focusView.hasFocus()) { 1896 focusView.requestFocus(); 1897 } 1898 appendVisibleItems(); 1899 prependVisibleItems(); 1900 removeInvisibleViewsAtFront(); 1901 removeInvisibleViewsAtEnd(); 1902 } while (mGrid.getFirstVisibleIndex() != oldFirstVisible || 1903 mGrid.getLastVisibleIndex() != oldLastVisible); 1904 } 1905 1906 if (scrollToFocus) { 1907 scrollDirectionPrimary(-delta); 1908 scrollDirectionSecondary(-deltaSecondary); 1909 } 1910 appendVisibleItems(); 1911 prependVisibleItems(); 1912 removeInvisibleViewsAtFront(); 1913 removeInvisibleViewsAtEnd(); 1914 1915 if (DEBUG) { 1916 StringWriter sw = new StringWriter(); 1917 PrintWriter pw = new PrintWriter(sw); 1918 mGrid.debugPrint(pw); 1919 Log.d(getTag(), sw.toString()); 1920 } 1921 1922 if (mRowSecondarySizeRefresh) { 1923 mRowSecondarySizeRefresh = false; 1924 } else { 1925 updateRowSecondarySizeRefresh(); 1926 } 1927 1928 // For fastRelayout, only dispatch event when focus position changes. 1929 if (mInFastRelayout && (mFocusPosition != savedFocusPos || mSubFocusPosition != 1930 savedSubFocusPos || findViewByPosition(mFocusPosition) != savedFocusView)) { 1931 dispatchChildSelected(); 1932 } else if (!mInFastRelayout && mInLayoutSearchFocus) { 1933 // For full layout we dispatchChildSelected() in createItem() unless searched all 1934 // children and found none is focusable then dispatchChildSelected() here. 1935 dispatchChildSelected(); 1936 } 1937 1938 mInLayout = false; 1939 leaveContext(); 1940 if (DEBUG) Log.v(getTag(), "layoutChildren end"); 1941 } 1942 1943 private void offsetChildrenSecondary(int increment) { 1944 final int childCount = getChildCount(); 1945 if (mOrientation == HORIZONTAL) { 1946 for (int i = 0; i < childCount; i++) { 1947 getChildAt(i).offsetTopAndBottom(increment); 1948 } 1949 } else { 1950 for (int i = 0; i < childCount; i++) { 1951 getChildAt(i).offsetLeftAndRight(increment); 1952 } 1953 } 1954 } 1955 1956 private void offsetChildrenPrimary(int increment) { 1957 final int childCount = getChildCount(); 1958 if (mOrientation == VERTICAL) { 1959 for (int i = 0; i < childCount; i++) { 1960 getChildAt(i).offsetTopAndBottom(increment); 1961 } 1962 } else { 1963 for (int i = 0; i < childCount; i++) { 1964 getChildAt(i).offsetLeftAndRight(increment); 1965 } 1966 } 1967 } 1968 1969 @Override 1970 public int scrollHorizontallyBy(int dx, Recycler recycler, RecyclerView.State state) { 1971 if (DEBUG) Log.v(getTag(), "scrollHorizontallyBy " + dx); 1972 if (!mLayoutEnabled || !hasDoneFirstLayout()) { 1973 return 0; 1974 } 1975 saveContext(recycler, state); 1976 mInScroll = true; 1977 int result; 1978 if (mOrientation == HORIZONTAL) { 1979 result = scrollDirectionPrimary(dx); 1980 } else { 1981 result = scrollDirectionSecondary(dx); 1982 } 1983 leaveContext(); 1984 mInScroll = false; 1985 return result; 1986 } 1987 1988 @Override 1989 public int scrollVerticallyBy(int dy, Recycler recycler, RecyclerView.State state) { 1990 if (DEBUG) Log.v(getTag(), "scrollVerticallyBy " + dy); 1991 if (!mLayoutEnabled || !hasDoneFirstLayout()) { 1992 return 0; 1993 } 1994 mInScroll = true; 1995 saveContext(recycler, state); 1996 int result; 1997 if (mOrientation == VERTICAL) { 1998 result = scrollDirectionPrimary(dy); 1999 } else { 2000 result = scrollDirectionSecondary(dy); 2001 } 2002 leaveContext(); 2003 mInScroll = false; 2004 return result; 2005 } 2006 2007 // scroll in main direction may add/prune views 2008 private int scrollDirectionPrimary(int da) { 2009 if (TRACE) TraceHelper.beginSection("scrollPrimary"); 2010 boolean isMaxUnknown = false, isMinUnknown = false; 2011 int minScroll = 0, maxScroll = 0; 2012 if (da > 0) { 2013 isMaxUnknown = mWindowAlignment.mainAxis().isMaxUnknown(); 2014 if (!isMaxUnknown) { 2015 maxScroll = mWindowAlignment.mainAxis().getMaxScroll(); 2016 if (mScrollOffsetPrimary + da > maxScroll) { 2017 da = maxScroll - mScrollOffsetPrimary; 2018 } 2019 } 2020 } else if (da < 0) { 2021 isMinUnknown = mWindowAlignment.mainAxis().isMinUnknown(); 2022 if (!isMinUnknown) { 2023 minScroll = mWindowAlignment.mainAxis().getMinScroll(); 2024 if (mScrollOffsetPrimary + da < minScroll) { 2025 da = minScroll - mScrollOffsetPrimary; 2026 } 2027 } 2028 } 2029 if (da == 0) { 2030 if (TRACE) TraceHelper.endSection(); 2031 return 0; 2032 } 2033 offsetChildrenPrimary(-da); 2034 mScrollOffsetPrimary += da; 2035 if (mInLayout) { 2036 if (TRACE) TraceHelper.endSection(); 2037 return da; 2038 } 2039 2040 int childCount = getChildCount(); 2041 boolean updated; 2042 2043 if (mReverseFlowPrimary ? da > 0 : da < 0) { 2044 prependVisibleItems(); 2045 } else { 2046 appendVisibleItems(); 2047 } 2048 updated = getChildCount() > childCount; 2049 childCount = getChildCount(); 2050 2051 if (TRACE) TraceHelper.beginSection("remove"); 2052 if (mReverseFlowPrimary ? da > 0 : da < 0) { 2053 removeInvisibleViewsAtEnd(); 2054 } else { 2055 removeInvisibleViewsAtFront(); 2056 } 2057 if (TRACE) TraceHelper.endSection(); 2058 updated |= getChildCount() < childCount; 2059 if (updated) { 2060 updateRowSecondarySizeRefresh(); 2061 } 2062 2063 mBaseGridView.invalidate(); 2064 if (TRACE) TraceHelper.endSection(); 2065 return da; 2066 } 2067 2068 // scroll in second direction will not add/prune views 2069 private int scrollDirectionSecondary(int dy) { 2070 if (dy == 0) { 2071 return 0; 2072 } 2073 offsetChildrenSecondary(-dy); 2074 mScrollOffsetSecondary += dy; 2075 mBaseGridView.invalidate(); 2076 return dy; 2077 } 2078 2079 private void updateScrollMax() { 2080 int highVisiblePos = (!mReverseFlowPrimary) ? mGrid.getLastVisibleIndex() 2081 : mGrid.getFirstVisibleIndex(); 2082 int highMaxPos = (!mReverseFlowPrimary) ? mState.getItemCount() - 1 : 0; 2083 if (highVisiblePos < 0) { 2084 return; 2085 } 2086 final boolean highAvailable = highVisiblePos == highMaxPos; 2087 final boolean maxUnknown = mWindowAlignment.mainAxis().isMaxUnknown(); 2088 if (!highAvailable && maxUnknown) { 2089 return; 2090 } 2091 int maxEdge = mGrid.findRowMax(true, sTwoInts) + mScrollOffsetPrimary; 2092 int rowIndex = sTwoInts[0]; 2093 int pos = sTwoInts[1]; 2094 int savedMaxEdge = mWindowAlignment.mainAxis().getMaxEdge(); 2095 mWindowAlignment.mainAxis().setMaxEdge(maxEdge); 2096 int maxScroll = getPrimarySystemScrollPositionOfChildMax(findViewByPosition(pos)); 2097 mWindowAlignment.mainAxis().setMaxEdge(savedMaxEdge); 2098 2099 if (highAvailable) { 2100 mWindowAlignment.mainAxis().setMaxEdge(maxEdge); 2101 mWindowAlignment.mainAxis().setMaxScroll(maxScroll); 2102 if (DEBUG) Log.v(getTag(), "updating scroll maxEdge to " + maxEdge + 2103 " scrollMax to " + maxScroll); 2104 } else { 2105 mWindowAlignment.mainAxis().invalidateScrollMax(); 2106 if (DEBUG) Log.v(getTag(), "Invalidate scrollMax since it should be " 2107 + "greater than " + maxScroll); 2108 } 2109 } 2110 2111 private void updateScrollMin() { 2112 int lowVisiblePos = (!mReverseFlowPrimary) ? mGrid.getFirstVisibleIndex() 2113 : mGrid.getLastVisibleIndex(); 2114 int lowMinPos = (!mReverseFlowPrimary) ? 0 : mState.getItemCount() - 1; 2115 if (lowVisiblePos < 0) { 2116 return; 2117 } 2118 final boolean lowAvailable = lowVisiblePos == lowMinPos; 2119 final boolean minUnknown = mWindowAlignment.mainAxis().isMinUnknown(); 2120 if (!lowAvailable && minUnknown) { 2121 return; 2122 } 2123 int minEdge = mGrid.findRowMin(false, sTwoInts) + mScrollOffsetPrimary; 2124 int rowIndex = sTwoInts[0]; 2125 int pos = sTwoInts[1]; 2126 int savedMinEdge = mWindowAlignment.mainAxis().getMinEdge(); 2127 mWindowAlignment.mainAxis().setMinEdge(minEdge); 2128 int minScroll = getPrimarySystemScrollPosition(findViewByPosition(pos)); 2129 mWindowAlignment.mainAxis().setMinEdge(savedMinEdge); 2130 2131 if (lowAvailable) { 2132 mWindowAlignment.mainAxis().setMinEdge(minEdge); 2133 mWindowAlignment.mainAxis().setMinScroll(minScroll); 2134 if (DEBUG) Log.v(getTag(), "updating scroll minEdge to " + minEdge + 2135 " scrollMin to " + minScroll); 2136 } else { 2137 mWindowAlignment.mainAxis().invalidateScrollMin(); 2138 if (DEBUG) Log.v(getTag(), "Invalidate scrollMin, since it should be " 2139 + "less than " + minScroll); 2140 } 2141 } 2142 2143 private void updateScrollSecondAxis() { 2144 mWindowAlignment.secondAxis().setMinEdge(0); 2145 mWindowAlignment.secondAxis().setMaxEdge(getSizeSecondary()); 2146 } 2147 2148 private void initScrollController() { 2149 mWindowAlignment.reset(); 2150 mWindowAlignment.horizontal.setSize(getWidth()); 2151 mWindowAlignment.vertical.setSize(getHeight()); 2152 mWindowAlignment.horizontal.setPadding(getPaddingLeft(), getPaddingRight()); 2153 mWindowAlignment.vertical.setPadding(getPaddingTop(), getPaddingBottom()); 2154 mSizePrimary = mWindowAlignment.mainAxis().getSize(); 2155 mScrollOffsetPrimary = -mWindowAlignment.mainAxis().getPaddingLow(); 2156 mScrollOffsetSecondary = -mWindowAlignment.secondAxis().getPaddingLow(); 2157 2158 if (DEBUG) { 2159 Log.v(getTag(), "initScrollController mSizePrimary " + mSizePrimary 2160 + " mWindowAlignment " + mWindowAlignment 2161 + " mScrollOffsetPrimary " + mScrollOffsetPrimary); 2162 } 2163 } 2164 2165 private void updateScrollController() { 2166 // mScrollOffsetPrimary and mScrollOffsetSecondary includes the padding. 2167 // e.g. when topPadding is 16 for horizontal grid view, the initial 2168 // mScrollOffsetSecondary is -16. fastRelayout() put views based on offsets(not padding), 2169 // when padding changes to 20, we also need update mScrollOffsetSecondary to -20 before 2170 // fastRelayout() is performed 2171 int paddingPrimaryDiff, paddingSecondaryDiff; 2172 if (mOrientation == HORIZONTAL) { 2173 paddingPrimaryDiff = getPaddingLeft() - mWindowAlignment.horizontal.getPaddingLow(); 2174 paddingSecondaryDiff = getPaddingTop() - mWindowAlignment.vertical.getPaddingLow(); 2175 } else { 2176 paddingPrimaryDiff = getPaddingTop() - mWindowAlignment.vertical.getPaddingLow(); 2177 paddingSecondaryDiff = getPaddingLeft() - mWindowAlignment.horizontal.getPaddingLow(); 2178 } 2179 mScrollOffsetPrimary -= paddingPrimaryDiff; 2180 mScrollOffsetSecondary -= paddingSecondaryDiff; 2181 2182 mWindowAlignment.horizontal.setSize(getWidth()); 2183 mWindowAlignment.vertical.setSize(getHeight()); 2184 mWindowAlignment.horizontal.setPadding(getPaddingLeft(), getPaddingRight()); 2185 mWindowAlignment.vertical.setPadding(getPaddingTop(), getPaddingBottom()); 2186 mSizePrimary = mWindowAlignment.mainAxis().getSize(); 2187 2188 if (DEBUG) { 2189 Log.v(getTag(), "updateScrollController mSizePrimary " + mSizePrimary 2190 + " mWindowAlignment " + mWindowAlignment 2191 + " mScrollOffsetPrimary " + mScrollOffsetPrimary); 2192 } 2193 } 2194 2195 public void setSelection(RecyclerView parent, int position, 2196 int primaryScrollExtra) { 2197 setSelection(parent, position, 0, false, primaryScrollExtra); 2198 } 2199 2200 public void setSelectionSmooth(RecyclerView parent, int position) { 2201 setSelection(parent, position, 0, true, 0); 2202 } 2203 2204 public void setSelectionWithSub(RecyclerView parent, int position, int subposition, 2205 int primaryScrollExtra) { 2206 setSelection(parent, position, subposition, false, primaryScrollExtra); 2207 } 2208 2209 public void setSelectionSmoothWithSub(RecyclerView parent, int position, int subposition) { 2210 setSelection(parent, position, subposition, true, 0); 2211 } 2212 2213 public int getSelection() { 2214 return mFocusPosition; 2215 } 2216 2217 public int getSubSelection() { 2218 return mSubFocusPosition; 2219 } 2220 2221 public void setSelection(RecyclerView parent, int position, int subposition, boolean smooth, 2222 int primaryScrollExtra) { 2223 if (mFocusPosition != position && position != NO_POSITION 2224 || subposition != mSubFocusPosition || primaryScrollExtra != mPrimaryScrollExtra) { 2225 scrollToSelection(parent, position, subposition, smooth, primaryScrollExtra); 2226 } 2227 } 2228 2229 private void scrollToSelection(RecyclerView parent, int position, int subposition, 2230 boolean smooth, int primaryScrollExtra) { 2231 if (TRACE) TraceHelper.beginSection("scrollToSelection"); 2232 mPrimaryScrollExtra = primaryScrollExtra; 2233 View view = findViewByPosition(position); 2234 if (view != null) { 2235 mInSelection = true; 2236 scrollToView(view, smooth); 2237 mInSelection = false; 2238 } else { 2239 mFocusPosition = position; 2240 mSubFocusPosition = subposition; 2241 mFocusPositionOffset = Integer.MIN_VALUE; 2242 if (!mLayoutEnabled) { 2243 return; 2244 } 2245 if (smooth) { 2246 if (!hasDoneFirstLayout()) { 2247 Log.w(getTag(), "setSelectionSmooth should " + 2248 "not be called before first layout pass"); 2249 return; 2250 } 2251 startPositionSmoothScroller(position); 2252 } else { 2253 mForceFullLayout = true; 2254 parent.requestLayout(); 2255 } 2256 } 2257 if (TRACE) TraceHelper.endSection(); 2258 } 2259 2260 void startPositionSmoothScroller(int position) { 2261 LinearSmoothScroller linearSmoothScroller = new GridLinearSmoothScroller() { 2262 @Override 2263 public PointF computeScrollVectorForPosition(int targetPosition) { 2264 if (getChildCount() == 0) { 2265 return null; 2266 } 2267 final int firstChildPos = getPosition(getChildAt(0)); 2268 // TODO We should be able to deduce direction from bounds of current and target 2269 // focus, rather than making assumptions about positions and directionality 2270 final boolean isStart = mReverseFlowPrimary ? targetPosition > firstChildPos 2271 : targetPosition < firstChildPos; 2272 final int direction = isStart ? -1 : 1; 2273 if (mOrientation == HORIZONTAL) { 2274 return new PointF(direction, 0); 2275 } else { 2276 return new PointF(0, direction); 2277 } 2278 } 2279 2280 }; 2281 linearSmoothScroller.setTargetPosition(position); 2282 startSmoothScroll(linearSmoothScroller); 2283 } 2284 2285 private void processPendingMovement(boolean forward) { 2286 if (forward ? hasCreatedLastItem() : hasCreatedFirstItem()) { 2287 return; 2288 } 2289 if (mPendingMoveSmoothScroller == null) { 2290 // Stop existing scroller and create a new PendingMoveSmoothScroller. 2291 mBaseGridView.stopScroll(); 2292 PendingMoveSmoothScroller linearSmoothScroller = new PendingMoveSmoothScroller( 2293 forward ? 1 : -1, mNumRows > 1); 2294 mFocusPositionOffset = 0; 2295 startSmoothScroll(linearSmoothScroller); 2296 if (linearSmoothScroller.isRunning()) { 2297 mPendingMoveSmoothScroller = linearSmoothScroller; 2298 } 2299 } else { 2300 if (forward) { 2301 mPendingMoveSmoothScroller.increasePendingMoves(); 2302 } else { 2303 mPendingMoveSmoothScroller.decreasePendingMoves(); 2304 } 2305 } 2306 } 2307 2308 @Override 2309 public void onItemsAdded(RecyclerView recyclerView, int positionStart, int itemCount) { 2310 if (DEBUG) Log.v(getTag(), "onItemsAdded positionStart " 2311 + positionStart + " itemCount " + itemCount); 2312 if (mFocusPosition != NO_POSITION && mFocusPositionOffset != Integer.MIN_VALUE) { 2313 int pos = mFocusPosition + mFocusPositionOffset; 2314 if (positionStart <= pos) { 2315 mFocusPositionOffset += itemCount; 2316 } 2317 } 2318 mChildrenStates.clear(); 2319 } 2320 2321 @Override 2322 public void onItemsChanged(RecyclerView recyclerView) { 2323 if (DEBUG) Log.v(getTag(), "onItemsChanged"); 2324 mFocusPositionOffset = 0; 2325 mChildrenStates.clear(); 2326 } 2327 2328 @Override 2329 public void onItemsRemoved(RecyclerView recyclerView, int positionStart, int itemCount) { 2330 if (DEBUG) Log.v(getTag(), "onItemsRemoved positionStart " 2331 + positionStart + " itemCount " + itemCount); 2332 if (mFocusPosition != NO_POSITION && mFocusPositionOffset != Integer.MIN_VALUE) { 2333 int pos = mFocusPosition + mFocusPositionOffset; 2334 if (positionStart <= pos) { 2335 if (positionStart + itemCount > pos) { 2336 // stop updating offset after the focus item was removed 2337 mFocusPositionOffset = Integer.MIN_VALUE; 2338 } else { 2339 mFocusPositionOffset -= itemCount; 2340 } 2341 } 2342 } 2343 mChildrenStates.clear(); 2344 } 2345 2346 @Override 2347 public void onItemsMoved(RecyclerView recyclerView, int fromPosition, int toPosition, 2348 int itemCount) { 2349 if (DEBUG) Log.v(getTag(), "onItemsMoved fromPosition " 2350 + fromPosition + " toPosition " + toPosition); 2351 if (mFocusPosition != NO_POSITION && mFocusPositionOffset != Integer.MIN_VALUE) { 2352 int pos = mFocusPosition + mFocusPositionOffset; 2353 if (fromPosition <= pos && pos < fromPosition + itemCount) { 2354 // moved items include focused position 2355 mFocusPositionOffset += toPosition - fromPosition; 2356 } else if (fromPosition < pos && toPosition > pos - itemCount) { 2357 // move items before focus position to after focused position 2358 mFocusPositionOffset -= itemCount; 2359 } else if (fromPosition > pos && toPosition < pos) { 2360 // move items after focus position to before focused position 2361 mFocusPositionOffset += itemCount; 2362 } 2363 } 2364 mChildrenStates.clear(); 2365 } 2366 2367 @Override 2368 public void onItemsUpdated(RecyclerView recyclerView, int positionStart, int itemCount) { 2369 if (DEBUG) Log.v(getTag(), "onItemsUpdated positionStart " 2370 + positionStart + " itemCount " + itemCount); 2371 for (int i = positionStart, end = positionStart + itemCount; i < end; i++) { 2372 mChildrenStates.remove(i); 2373 } 2374 } 2375 2376 @Override 2377 public boolean onRequestChildFocus(RecyclerView parent, View child, View focused) { 2378 if (mFocusSearchDisabled) { 2379 return true; 2380 } 2381 if (getPositionByView(child) == NO_POSITION) { 2382 // This shouldn't happen, but in case it does be sure not to attempt a 2383 // scroll to a view whose item has been removed. 2384 return true; 2385 } 2386 if (!mInLayout && !mInSelection && !mInScroll) { 2387 scrollToView(child, focused, true); 2388 } 2389 return true; 2390 } 2391 2392 @Override 2393 public boolean requestChildRectangleOnScreen(RecyclerView parent, View view, Rect rect, 2394 boolean immediate) { 2395 if (DEBUG) Log.v(getTag(), "requestChildRectangleOnScreen " + view + " " + rect); 2396 return false; 2397 } 2398 2399 int getScrollOffsetX() { 2400 return mOrientation == HORIZONTAL ? mScrollOffsetPrimary : mScrollOffsetSecondary; 2401 } 2402 2403 int getScrollOffsetY() { 2404 return mOrientation == HORIZONTAL ? mScrollOffsetSecondary : mScrollOffsetPrimary; 2405 } 2406 2407 public void getViewSelectedOffsets(View view, int[] offsets) { 2408 if (mOrientation == HORIZONTAL) { 2409 offsets[0] = getPrimarySystemScrollPosition(view) - mScrollOffsetPrimary; 2410 offsets[1] = getSecondarySystemScrollPosition(view) - mScrollOffsetSecondary; 2411 } else { 2412 offsets[1] = getPrimarySystemScrollPosition(view) - mScrollOffsetPrimary; 2413 offsets[0] = getSecondarySystemScrollPosition(view) - mScrollOffsetSecondary; 2414 } 2415 } 2416 2417 private int getPrimarySystemScrollPosition(View view) { 2418 final int viewCenterPrimary = mScrollOffsetPrimary + getViewCenter(view); 2419 final int viewMin = getViewMin(view); 2420 final int viewMax = getViewMax(view); 2421 // TODO: change to use State object in onRequestChildFocus() 2422 boolean isMin, isMax; 2423 if (!mReverseFlowPrimary) { 2424 isMin = mGrid.getFirstVisibleIndex() == 0; 2425 isMax = mGrid.getLastVisibleIndex() == (mState == null ? 2426 getItemCount() : mState.getItemCount()) - 1; 2427 } else { 2428 isMax = mGrid.getFirstVisibleIndex() == 0; 2429 isMin = mGrid.getLastVisibleIndex() == (mState == null ? 2430 getItemCount() : mState.getItemCount()) - 1; 2431 } 2432 for (int i = getChildCount() - 1; (isMin || isMax) && i >= 0; i--) { 2433 View v = getChildAt(i); 2434 if (v == view || v == null) { 2435 continue; 2436 } 2437 if (isMin && getViewMin(v) < viewMin) { 2438 isMin = false; 2439 } 2440 if (isMax && getViewMax(v) > viewMax) { 2441 isMax = false; 2442 } 2443 } 2444 return mWindowAlignment.mainAxis().getSystemScrollPos(viewCenterPrimary, isMin, isMax); 2445 } 2446 2447 private int getPrimarySystemScrollPositionOfChildMax(View view) { 2448 int scrollPosition = getPrimarySystemScrollPosition(view); 2449 final LayoutParams lp = (LayoutParams) view.getLayoutParams(); 2450 int[] multipleAligns = lp.getAlignMultiple(); 2451 if (multipleAligns != null && multipleAligns.length > 0) { 2452 scrollPosition += multipleAligns[multipleAligns.length - 1] - multipleAligns[0]; 2453 } 2454 return scrollPosition; 2455 } 2456 2457 /** 2458 * Get adjusted primary position for a given childView (if there is multiple ItemAlignment defined 2459 * on the view). 2460 */ 2461 private int getAdjustedPrimaryScrollPosition(int scrollPrimary, View view, View childView) { 2462 int subindex = getSubPositionByView(view, childView); 2463 if (subindex != 0) { 2464 final LayoutParams lp = (LayoutParams) view.getLayoutParams(); 2465 scrollPrimary += lp.getAlignMultiple()[subindex] - lp.getAlignMultiple()[0]; 2466 } 2467 return scrollPrimary; 2468 } 2469 2470 private int getSecondarySystemScrollPosition(View view) { 2471 int viewCenterSecondary = mScrollOffsetSecondary + getViewCenterSecondary(view); 2472 int pos = getPositionByView(view); 2473 Grid.Location location = mGrid.getLocation(pos); 2474 final int row = location.row; 2475 final boolean isMin, isMax; 2476 if (!mReverseFlowSecondary) { 2477 isMin = row == 0; 2478 isMax = row == mGrid.getNumRows() - 1; 2479 } else { 2480 isMax = row == 0; 2481 isMin = row == mGrid.getNumRows() - 1; 2482 } 2483 return mWindowAlignment.secondAxis().getSystemScrollPos(viewCenterSecondary, isMin, isMax); 2484 } 2485 2486 /** 2487 * Scroll to a given child view and change mFocusPosition. 2488 */ 2489 private void scrollToView(View view, boolean smooth) { 2490 scrollToView(view, view == null ? null : view.findFocus(), smooth); 2491 } 2492 2493 /** 2494 * Scroll to a given child view and change mFocusPosition. 2495 */ 2496 private void scrollToView(View view, View childView, boolean smooth) { 2497 int newFocusPosition = getPositionByView(view); 2498 int newSubFocusPosition = getSubPositionByView(view, childView); 2499 if (newFocusPosition != mFocusPosition || newSubFocusPosition != mSubFocusPosition) { 2500 mFocusPosition = newFocusPosition; 2501 mSubFocusPosition = newSubFocusPosition; 2502 mFocusPositionOffset = 0; 2503 if (!mInLayout) { 2504 dispatchChildSelected(); 2505 } 2506 if (mBaseGridView.isChildrenDrawingOrderEnabledInternal()) { 2507 mBaseGridView.invalidate(); 2508 } 2509 } 2510 if (view == null) { 2511 return; 2512 } 2513 if (!view.hasFocus() && mBaseGridView.hasFocus()) { 2514 // transfer focus to the child if it does not have focus yet (e.g. triggered 2515 // by setSelection()) 2516 view.requestFocus(); 2517 } 2518 if (!mScrollEnabled && smooth) { 2519 return; 2520 } 2521 if (getScrollPosition(view, childView, sTwoInts)) { 2522 scrollGrid(sTwoInts[0], sTwoInts[1], smooth); 2523 } 2524 } 2525 2526 private boolean getScrollPosition(View view, View childView, int[] deltas) { 2527 switch (mFocusScrollStrategy) { 2528 case BaseGridView.FOCUS_SCROLL_ALIGNED: 2529 default: 2530 return getAlignedPosition(view, childView, deltas); 2531 case BaseGridView.FOCUS_SCROLL_ITEM: 2532 case BaseGridView.FOCUS_SCROLL_PAGE: 2533 return getNoneAlignedPosition(view, deltas); 2534 } 2535 } 2536 2537 private boolean getNoneAlignedPosition(View view, int[] deltas) { 2538 int pos = getPositionByView(view); 2539 int viewMin = getViewMin(view); 2540 int viewMax = getViewMax(view); 2541 // we either align "firstView" to left/top padding edge 2542 // or align "lastView" to right/bottom padding edge 2543 View firstView = null; 2544 View lastView = null; 2545 int paddingLow = mWindowAlignment.mainAxis().getPaddingLow(); 2546 int clientSize = mWindowAlignment.mainAxis().getClientSize(); 2547 final int row = mGrid.getRowIndex(pos); 2548 if (viewMin < paddingLow) { 2549 // view enters low padding area: 2550 firstView = view; 2551 if (mFocusScrollStrategy == BaseGridView.FOCUS_SCROLL_PAGE) { 2552 // scroll one "page" left/top, 2553 // align first visible item of the "page" at the low padding edge. 2554 while (prependOneColumnVisibleItems()) { 2555 CircularIntArray positions = 2556 mGrid.getItemPositionsInRows(mGrid.getFirstVisibleIndex(), pos)[row]; 2557 firstView = findViewByPosition(positions.get(0)); 2558 if (viewMax - getViewMin(firstView) > clientSize) { 2559 if (positions.size() > 2) { 2560 firstView = findViewByPosition(positions.get(2)); 2561 } 2562 break; 2563 } 2564 } 2565 } 2566 } else if (viewMax > clientSize + paddingLow) { 2567 // view enters high padding area: 2568 if (mFocusScrollStrategy == BaseGridView.FOCUS_SCROLL_PAGE) { 2569 // scroll whole one page right/bottom, align view at the low padding edge. 2570 firstView = view; 2571 do { 2572 CircularIntArray positions = 2573 mGrid.getItemPositionsInRows(pos, mGrid.getLastVisibleIndex())[row]; 2574 lastView = findViewByPosition(positions.get(positions.size() - 1)); 2575 if (getViewMax(lastView) - viewMin > clientSize) { 2576 lastView = null; 2577 break; 2578 } 2579 } while (appendOneColumnVisibleItems()); 2580 if (lastView != null) { 2581 // however if we reached end, we should align last view. 2582 firstView = null; 2583 } 2584 } else { 2585 lastView = view; 2586 } 2587 } 2588 int scrollPrimary = 0; 2589 int scrollSecondary = 0; 2590 if (firstView != null) { 2591 scrollPrimary = getViewMin(firstView) - paddingLow; 2592 } else if (lastView != null) { 2593 scrollPrimary = getViewMax(lastView) - (paddingLow + clientSize); 2594 } 2595 View secondaryAlignedView; 2596 if (firstView != null) { 2597 secondaryAlignedView = firstView; 2598 } else if (lastView != null) { 2599 secondaryAlignedView = lastView; 2600 } else { 2601 secondaryAlignedView = view; 2602 } 2603 scrollSecondary = getSecondarySystemScrollPosition(secondaryAlignedView); 2604 scrollSecondary -= mScrollOffsetSecondary; 2605 if (scrollPrimary != 0 || scrollSecondary != 0) { 2606 deltas[0] = scrollPrimary; 2607 deltas[1] = scrollSecondary; 2608 return true; 2609 } 2610 return false; 2611 } 2612 2613 private boolean getAlignedPosition(View view, View childView, int[] deltas) { 2614 int scrollPrimary = getPrimarySystemScrollPosition(view); 2615 if (childView != null) { 2616 scrollPrimary = getAdjustedPrimaryScrollPosition(scrollPrimary, view, childView); 2617 } 2618 int scrollSecondary = getSecondarySystemScrollPosition(view); 2619 if (DEBUG) { 2620 Log.v(getTag(), "getAlignedPosition " + scrollPrimary + " " + scrollSecondary 2621 + " " + mPrimaryScrollExtra + " " + mWindowAlignment); 2622 Log.v(getTag(), "getAlignedPosition " + mScrollOffsetPrimary + " " + mScrollOffsetSecondary); 2623 } 2624 scrollPrimary -= mScrollOffsetPrimary; 2625 scrollSecondary -= mScrollOffsetSecondary; 2626 scrollPrimary += mPrimaryScrollExtra; 2627 if (scrollPrimary != 0 || scrollSecondary != 0) { 2628 deltas[0] = scrollPrimary; 2629 deltas[1] = scrollSecondary; 2630 return true; 2631 } 2632 return false; 2633 } 2634 2635 private void scrollGrid(int scrollPrimary, int scrollSecondary, boolean smooth) { 2636 if (mInLayout) { 2637 scrollDirectionPrimary(scrollPrimary); 2638 scrollDirectionSecondary(scrollSecondary); 2639 } else { 2640 int scrollX; 2641 int scrollY; 2642 if (mOrientation == HORIZONTAL) { 2643 scrollX = scrollPrimary; 2644 scrollY = scrollSecondary; 2645 } else { 2646 scrollX = scrollSecondary; 2647 scrollY = scrollPrimary; 2648 } 2649 if (smooth) { 2650 mBaseGridView.smoothScrollBy(scrollX, scrollY); 2651 } else { 2652 mBaseGridView.scrollBy(scrollX, scrollY); 2653 } 2654 } 2655 } 2656 2657 public void setPruneChild(boolean pruneChild) { 2658 if (mPruneChild != pruneChild) { 2659 mPruneChild = pruneChild; 2660 if (mPruneChild) { 2661 requestLayout(); 2662 } 2663 } 2664 } 2665 2666 public boolean getPruneChild() { 2667 return mPruneChild; 2668 } 2669 2670 public void setScrollEnabled(boolean scrollEnabled) { 2671 if (mScrollEnabled != scrollEnabled) { 2672 mScrollEnabled = scrollEnabled; 2673 if (mScrollEnabled && mFocusScrollStrategy == BaseGridView.FOCUS_SCROLL_ALIGNED 2674 && mFocusPosition != NO_POSITION) { 2675 scrollToSelection(mBaseGridView, mFocusPosition, mSubFocusPosition, 2676 true, mPrimaryScrollExtra); 2677 } 2678 } 2679 } 2680 2681 public boolean isScrollEnabled() { 2682 return mScrollEnabled; 2683 } 2684 2685 private int findImmediateChildIndex(View view) { 2686 while (view != null && view != mBaseGridView) { 2687 int index = mBaseGridView.indexOfChild(view); 2688 if (index >= 0) { 2689 return index; 2690 } 2691 view = (View) view.getParent(); 2692 } 2693 return NO_POSITION; 2694 } 2695 2696 void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) { 2697 if (gainFocus) { 2698 // if gridview.requestFocus() is called, select first focusable child. 2699 for (int i = mFocusPosition; ;i++) { 2700 View view = findViewByPosition(i); 2701 if (view == null) { 2702 break; 2703 } 2704 if (view.getVisibility() == View.VISIBLE && view.hasFocusable()) { 2705 view.requestFocus(); 2706 break; 2707 } 2708 } 2709 } 2710 } 2711 2712 void setFocusSearchDisabled(boolean disabled) { 2713 mFocusSearchDisabled = disabled; 2714 } 2715 2716 boolean isFocusSearchDisabled() { 2717 return mFocusSearchDisabled; 2718 } 2719 2720 @Override 2721 public View onInterceptFocusSearch(View focused, int direction) { 2722 if (mFocusSearchDisabled) { 2723 return focused; 2724 } 2725 return null; 2726 } 2727 2728 boolean hasPreviousViewInSameRow(int pos) { 2729 if (mGrid == null || pos == NO_POSITION || mGrid.getFirstVisibleIndex() < 0) { 2730 return false; 2731 } 2732 if (mGrid.getFirstVisibleIndex() > 0) { 2733 return true; 2734 } 2735 final int focusedRow = mGrid.getLocation(pos).row; 2736 for (int i = getChildCount() - 1; i >= 0; i--) { 2737 int position = getPositionByIndex(i); 2738 Grid.Location loc = mGrid.getLocation(position); 2739 if (loc != null && loc.row == focusedRow) { 2740 if (position < pos) { 2741 return true; 2742 } 2743 } 2744 } 2745 return false; 2746 } 2747 2748 @Override 2749 public boolean onAddFocusables(RecyclerView recyclerView, 2750 ArrayList<View> views, int direction, int focusableMode) { 2751 if (mFocusSearchDisabled) { 2752 return true; 2753 } 2754 // If this viewgroup or one of its children currently has focus then we 2755 // consider our children for focus searching in main direction on the same row. 2756 // If this viewgroup has no focus and using focus align, we want the system 2757 // to ignore our children and pass focus to the viewgroup, which will pass 2758 // focus on to its children appropriately. 2759 // If this viewgroup has no focus and not using focus align, we want to 2760 // consider the child that does not overlap with padding area. 2761 if (recyclerView.hasFocus()) { 2762 if (mPendingMoveSmoothScroller != null) { 2763 // don't find next focusable if has pending movement. 2764 return true; 2765 } 2766 final int movement = getMovement(direction); 2767 final View focused = recyclerView.findFocus(); 2768 final int focusedIndex = findImmediateChildIndex(focused); 2769 final int focusedPos = getPositionByIndex(focusedIndex); 2770 // Add focusables of focused item. 2771 if (focusedPos != NO_POSITION) { 2772 findViewByPosition(focusedPos).addFocusables(views, direction, focusableMode); 2773 } 2774 if (mGrid == null) { 2775 // no grid information, bail out. 2776 return true; 2777 } 2778 if ((movement == NEXT_ROW || movement == PREV_ROW) && mGrid.getNumRows() <= 1) { 2779 // For single row, cannot navigate to previous/next row. 2780 return true; 2781 } 2782 // Add focusables of neighbor depending on the focus search direction. 2783 final int focusedRow = mGrid != null && focusedPos != NO_POSITION ? 2784 mGrid.getLocation(focusedPos).row : NO_POSITION; 2785 final int focusableCount = views.size(); 2786 int inc = movement == NEXT_ITEM || movement == NEXT_ROW ? 1 : -1; 2787 int loop_end = inc > 0 ? getChildCount() - 1 : 0; 2788 int loop_start; 2789 if (focusedIndex == NO_POSITION) { 2790 loop_start = inc > 0 ? 0 : getChildCount() - 1; 2791 } else { 2792 loop_start = focusedIndex + inc; 2793 } 2794 for (int i = loop_start; inc > 0 ? i <= loop_end : i >= loop_end; i += inc) { 2795 final View child = getChildAt(i); 2796 if (child.getVisibility() != View.VISIBLE || !child.hasFocusable()) { 2797 continue; 2798 } 2799 // if there wasn't any focusing item, add the very first focusable 2800 // items and stop. 2801 if (focusedPos == NO_POSITION) { 2802 child.addFocusables(views, direction, focusableMode); 2803 if (views.size() > focusableCount) { 2804 break; 2805 } 2806 continue; 2807 } 2808 int position = getPositionByIndex(i); 2809 Grid.Location loc = mGrid.getLocation(position); 2810 if (loc == null) { 2811 continue; 2812 } 2813 if (movement == NEXT_ITEM) { 2814 // Add first focusable item on the same row 2815 if (loc.row == focusedRow && position > focusedPos) { 2816 child.addFocusables(views, direction, focusableMode); 2817 if (views.size() > focusableCount) { 2818 break; 2819 } 2820 } 2821 } else if (movement == PREV_ITEM) { 2822 // Add first focusable item on the same row 2823 if (loc.row == focusedRow && position < focusedPos) { 2824 child.addFocusables(views, direction, focusableMode); 2825 if (views.size() > focusableCount) { 2826 break; 2827 } 2828 } 2829 } else if (movement == NEXT_ROW) { 2830 // Add all focusable items after this item whose row index is bigger 2831 if (loc.row == focusedRow) { 2832 continue; 2833 } else if (loc.row < focusedRow) { 2834 break; 2835 } 2836 child.addFocusables(views, direction, focusableMode); 2837 } else if (movement == PREV_ROW) { 2838 // Add all focusable items before this item whose row index is smaller 2839 if (loc.row == focusedRow) { 2840 continue; 2841 } else if (loc.row > focusedRow) { 2842 break; 2843 } 2844 child.addFocusables(views, direction, focusableMode); 2845 } 2846 } 2847 } else { 2848 int focusableCount = views.size(); 2849 if (mFocusScrollStrategy != BaseGridView.FOCUS_SCROLL_ALIGNED) { 2850 // adding views not overlapping padding area to avoid scrolling in gaining focus 2851 int left = mWindowAlignment.mainAxis().getPaddingLow(); 2852 int right = mWindowAlignment.mainAxis().getClientSize() + left; 2853 for (int i = 0, count = getChildCount(); i < count; i++) { 2854 View child = getChildAt(i); 2855 if (child.getVisibility() == View.VISIBLE) { 2856 if (getViewMin(child) >= left && getViewMax(child) <= right) { 2857 child.addFocusables(views, direction, focusableMode); 2858 } 2859 } 2860 } 2861 // if we cannot find any, then just add all children. 2862 if (views.size() == focusableCount) { 2863 for (int i = 0, count = getChildCount(); i < count; i++) { 2864 View child = getChildAt(i); 2865 if (child.getVisibility() == View.VISIBLE) { 2866 child.addFocusables(views, direction, focusableMode); 2867 } 2868 } 2869 } 2870 } else { 2871 View view = findViewByPosition(mFocusPosition); 2872 if (view != null) { 2873 view.addFocusables(views, direction, focusableMode); 2874 } 2875 } 2876 // if still cannot find any, fall through and add itself 2877 if (views.size() != focusableCount) { 2878 return true; 2879 } 2880 if (recyclerView.isFocusable()) { 2881 views.add(recyclerView); 2882 } 2883 } 2884 return true; 2885 } 2886 2887 private boolean hasCreatedLastItem() { 2888 int count = mState.getItemCount(); 2889 return count == 0 || findViewByPosition(count - 1) != null; 2890 } 2891 2892 private boolean hasCreatedFirstItem() { 2893 int count = mState.getItemCount(); 2894 return count == 0 || findViewByPosition(0) != null; 2895 } 2896 2897 boolean canScrollTo(View view) { 2898 return view.getVisibility() == View.VISIBLE && (!hasFocus() || view.hasFocusable()); 2899 } 2900 2901 @Override 2902 public View onFocusSearchFailed(View focused, int direction, Recycler recycler, 2903 RecyclerView.State state) { 2904 if (DEBUG) Log.v(getTag(), "onFocusSearchFailed direction " + direction); 2905 2906 View view = null; 2907 int movement = getMovement(direction); 2908 final boolean isScroll = mBaseGridView.getScrollState() != RecyclerView.SCROLL_STATE_IDLE; 2909 saveContext(recycler, state); 2910 if (movement == NEXT_ITEM) { 2911 if (isScroll || !mFocusOutEnd) { 2912 view = focused; 2913 } 2914 if (mScrollEnabled && !hasCreatedLastItem()) { 2915 processPendingMovement(true); 2916 view = focused; 2917 } 2918 } else if (movement == PREV_ITEM) { 2919 if (isScroll || !mFocusOutFront) { 2920 view = focused; 2921 } 2922 if (mScrollEnabled && !hasCreatedFirstItem()) { 2923 processPendingMovement(false); 2924 view = focused; 2925 } 2926 } else if (movement == NEXT_ROW) { 2927 if (isScroll || !mFocusOutSideEnd) { 2928 view = focused; 2929 } 2930 } else if (movement == PREV_ROW) { 2931 if (isScroll || !mFocusOutSideStart) { 2932 view = focused; 2933 } 2934 } 2935 leaveContext(); 2936 if (DEBUG) Log.v(getTag(), "onFocusSearchFailed returning view " + view); 2937 return view; 2938 } 2939 2940 boolean gridOnRequestFocusInDescendants(RecyclerView recyclerView, int direction, 2941 Rect previouslyFocusedRect) { 2942 switch (mFocusScrollStrategy) { 2943 case BaseGridView.FOCUS_SCROLL_ALIGNED: 2944 default: 2945 return gridOnRequestFocusInDescendantsAligned(recyclerView, 2946 direction, previouslyFocusedRect); 2947 case BaseGridView.FOCUS_SCROLL_PAGE: 2948 case BaseGridView.FOCUS_SCROLL_ITEM: 2949 return gridOnRequestFocusInDescendantsUnaligned(recyclerView, 2950 direction, previouslyFocusedRect); 2951 } 2952 } 2953 2954 private boolean gridOnRequestFocusInDescendantsAligned(RecyclerView recyclerView, 2955 int direction, Rect previouslyFocusedRect) { 2956 View view = findViewByPosition(mFocusPosition); 2957 if (view != null) { 2958 boolean result = view.requestFocus(direction, previouslyFocusedRect); 2959 if (!result && DEBUG) { 2960 Log.w(getTag(), "failed to request focus on " + view); 2961 } 2962 return result; 2963 } 2964 return false; 2965 } 2966 2967 private boolean gridOnRequestFocusInDescendantsUnaligned(RecyclerView recyclerView, 2968 int direction, Rect previouslyFocusedRect) { 2969 // focus to view not overlapping padding area to avoid scrolling in gaining focus 2970 int index; 2971 int increment; 2972 int end; 2973 int count = getChildCount(); 2974 if ((direction & View.FOCUS_FORWARD) != 0) { 2975 index = 0; 2976 increment = 1; 2977 end = count; 2978 } else { 2979 index = count - 1; 2980 increment = -1; 2981 end = -1; 2982 } 2983 int left = mWindowAlignment.mainAxis().getPaddingLow(); 2984 int right = mWindowAlignment.mainAxis().getClientSize() + left; 2985 for (int i = index; i != end; i += increment) { 2986 View child = getChildAt(i); 2987 if (child.getVisibility() == View.VISIBLE) { 2988 if (getViewMin(child) >= left && getViewMax(child) <= right) { 2989 if (child.requestFocus(direction, previouslyFocusedRect)) { 2990 return true; 2991 } 2992 } 2993 } 2994 } 2995 return false; 2996 } 2997 2998 private final static int PREV_ITEM = 0; 2999 private final static int NEXT_ITEM = 1; 3000 private final static int PREV_ROW = 2; 3001 private final static int NEXT_ROW = 3; 3002 3003 private int getMovement(int direction) { 3004 int movement = View.FOCUS_LEFT; 3005 3006 if (mOrientation == HORIZONTAL) { 3007 switch(direction) { 3008 case View.FOCUS_LEFT: 3009 movement = (!mReverseFlowPrimary) ? PREV_ITEM : NEXT_ITEM; 3010 break; 3011 case View.FOCUS_RIGHT: 3012 movement = (!mReverseFlowPrimary) ? NEXT_ITEM : PREV_ITEM; 3013 break; 3014 case View.FOCUS_UP: 3015 movement = PREV_ROW; 3016 break; 3017 case View.FOCUS_DOWN: 3018 movement = NEXT_ROW; 3019 break; 3020 } 3021 } else if (mOrientation == VERTICAL) { 3022 switch(direction) { 3023 case View.FOCUS_LEFT: 3024 movement = (!mReverseFlowSecondary) ? PREV_ROW : NEXT_ROW; 3025 break; 3026 case View.FOCUS_RIGHT: 3027 movement = (!mReverseFlowSecondary) ? NEXT_ROW : PREV_ROW; 3028 break; 3029 case View.FOCUS_UP: 3030 movement = PREV_ITEM; 3031 break; 3032 case View.FOCUS_DOWN: 3033 movement = NEXT_ITEM; 3034 break; 3035 } 3036 } 3037 3038 return movement; 3039 } 3040 3041 int getChildDrawingOrder(RecyclerView recyclerView, int childCount, int i) { 3042 View view = findViewByPosition(mFocusPosition); 3043 if (view == null) { 3044 return i; 3045 } 3046 int focusIndex = recyclerView.indexOfChild(view); 3047 // supposely 0 1 2 3 4 5 6 7 8 9, 4 is the center item 3048 // drawing order is 0 1 2 3 9 8 7 6 5 4 3049 if (i < focusIndex) { 3050 return i; 3051 } else if (i < childCount - 1) { 3052 return focusIndex + childCount - 1 - i; 3053 } else { 3054 return focusIndex; 3055 } 3056 } 3057 3058 @Override 3059 public void onAdapterChanged(RecyclerView.Adapter oldAdapter, 3060 RecyclerView.Adapter newAdapter) { 3061 if (DEBUG) Log.v(getTag(), "onAdapterChanged to " + newAdapter); 3062 if (oldAdapter != null) { 3063 discardLayoutInfo(); 3064 mFocusPosition = NO_POSITION; 3065 mFocusPositionOffset = 0; 3066 mChildrenStates.clear(); 3067 } 3068 if (newAdapter instanceof FacetProviderAdapter) { 3069 mFacetProviderAdapter = (FacetProviderAdapter) newAdapter; 3070 } else { 3071 mFacetProviderAdapter = null; 3072 } 3073 super.onAdapterChanged(oldAdapter, newAdapter); 3074 } 3075 3076 private void discardLayoutInfo() { 3077 mGrid = null; 3078 mRowSizeSecondary = null; 3079 mRowSecondarySizeRefresh = false; 3080 } 3081 3082 public void setLayoutEnabled(boolean layoutEnabled) { 3083 if (mLayoutEnabled != layoutEnabled) { 3084 mLayoutEnabled = layoutEnabled; 3085 requestLayout(); 3086 } 3087 } 3088 3089 void setChildrenVisibility(int visiblity) { 3090 mChildVisibility = visiblity; 3091 if (mChildVisibility != -1) { 3092 int count = getChildCount(); 3093 for (int i= 0; i < count; i++) { 3094 getChildAt(i).setVisibility(mChildVisibility); 3095 } 3096 } 3097 } 3098 3099 final static class SavedState implements Parcelable { 3100 3101 int index; // index inside adapter of the current view 3102 Bundle childStates = Bundle.EMPTY; 3103 3104 @Override 3105 public void writeToParcel(Parcel out, int flags) { 3106 out.writeInt(index); 3107 out.writeBundle(childStates); 3108 } 3109 3110 @SuppressWarnings("hiding") 3111 public static final Parcelable.Creator<SavedState> CREATOR = 3112 new Parcelable.Creator<SavedState>() { 3113 @Override 3114 public SavedState createFromParcel(Parcel in) { 3115 return new SavedState(in); 3116 } 3117 3118 @Override 3119 public SavedState[] newArray(int size) { 3120 return new SavedState[size]; 3121 } 3122 }; 3123 3124 @Override 3125 public int describeContents() { 3126 return 0; 3127 } 3128 3129 SavedState(Parcel in) { 3130 index = in.readInt(); 3131 childStates = in.readBundle(GridLayoutManager.class.getClassLoader()); 3132 } 3133 3134 SavedState() { 3135 } 3136 } 3137 3138 @Override 3139 public Parcelable onSaveInstanceState() { 3140 if (DEBUG) Log.v(getTag(), "onSaveInstanceState getSelection() " + getSelection()); 3141 SavedState ss = new SavedState(); 3142 // save selected index 3143 ss.index = getSelection(); 3144 // save offscreen child (state when they are recycled) 3145 Bundle bundle = mChildrenStates.saveAsBundle(); 3146 // save views currently is on screen (TODO save cached views) 3147 for (int i = 0, count = getChildCount(); i < count; i++) { 3148 View view = getChildAt(i); 3149 int position = getPositionByView(view); 3150 if (position != NO_POSITION) { 3151 bundle = mChildrenStates.saveOnScreenView(bundle, view, position); 3152 } 3153 } 3154 ss.childStates = bundle; 3155 return ss; 3156 } 3157 3158 void onChildRecycled(RecyclerView.ViewHolder holder) { 3159 final int position = holder.getAdapterPosition(); 3160 if (position != NO_POSITION) { 3161 mChildrenStates.saveOffscreenView(holder.itemView, position); 3162 } 3163 } 3164 3165 @Override 3166 public void onRestoreInstanceState(Parcelable state) { 3167 if (!(state instanceof SavedState)) { 3168 return; 3169 } 3170 SavedState loadingState = (SavedState)state; 3171 mFocusPosition = loadingState.index; 3172 mFocusPositionOffset = 0; 3173 mChildrenStates.loadFromBundle(loadingState.childStates); 3174 mForceFullLayout = true; 3175 requestLayout(); 3176 if (DEBUG) Log.v(getTag(), "onRestoreInstanceState mFocusPosition " + mFocusPosition); 3177 } 3178 3179 @Override 3180 public int getRowCountForAccessibility(RecyclerView.Recycler recycler, 3181 RecyclerView.State state) { 3182 if (mOrientation == HORIZONTAL && mGrid != null) { 3183 return mGrid.getNumRows(); 3184 } 3185 return super.getRowCountForAccessibility(recycler, state); 3186 } 3187 3188 @Override 3189 public int getColumnCountForAccessibility(RecyclerView.Recycler recycler, 3190 RecyclerView.State state) { 3191 if (mOrientation == VERTICAL && mGrid != null) { 3192 return mGrid.getNumRows(); 3193 } 3194 return super.getColumnCountForAccessibility(recycler, state); 3195 } 3196 3197 @Override 3198 public void onInitializeAccessibilityNodeInfoForItem(RecyclerView.Recycler recycler, 3199 RecyclerView.State state, View host, AccessibilityNodeInfoCompat info) { 3200 ViewGroup.LayoutParams lp = host.getLayoutParams(); 3201 if (mGrid == null || !(lp instanceof LayoutParams)) { 3202 super.onInitializeAccessibilityNodeInfoForItem(recycler, state, host, info); 3203 return; 3204 } 3205 LayoutParams glp = (LayoutParams) lp; 3206 int position = glp.getViewLayoutPosition(); 3207 int rowIndex = mGrid.getRowIndex(position); 3208 int guessSpanIndex = position / mGrid.getNumRows(); 3209 if (mOrientation == HORIZONTAL) { 3210 info.setCollectionItemInfo(AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain( 3211 rowIndex, 1, guessSpanIndex, 1, false, false)); 3212 } else { 3213 info.setCollectionItemInfo(AccessibilityNodeInfoCompat.CollectionItemInfoCompat.obtain( 3214 guessSpanIndex, 1, rowIndex, 1, false, false)); 3215 } 3216 } 3217 3218 /* 3219 * Leanback widget is different than the default implementation because the "scroll" is driven 3220 * by selection change. 3221 */ 3222 @Override 3223 public boolean performAccessibilityAction(Recycler recycler, State state, int action, 3224 Bundle args) { 3225 saveContext(recycler, state); 3226 switch (action) { 3227 case AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD: 3228 // try to focus all the way to the last visible item on the same row. 3229 processSelectionMoves(false, -mState.getItemCount()); 3230 break; 3231 case AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD: 3232 processSelectionMoves(false, mState.getItemCount()); 3233 break; 3234 } 3235 leaveContext(); 3236 return true; 3237 } 3238 3239 /* 3240 * Move mFocusPosition multiple steps on the same row in main direction. 3241 * Stops when moves are all consumed or reach first/last visible item. 3242 * Returning remaining moves. 3243 */ 3244 private int processSelectionMoves(boolean preventScroll, int moves) { 3245 if (mGrid == null) { 3246 return moves; 3247 } 3248 int focusPosition = mFocusPosition; 3249 int focusedRow = focusPosition != NO_POSITION ? 3250 mGrid.getRowIndex(focusPosition) : NO_POSITION; 3251 View newSelected = null; 3252 for (int i = 0, count = getChildCount(); i < count && moves != 0; i++) { 3253 int index = moves > 0 ? i : count - 1 - i; 3254 final View child = getChildAt(index); 3255 if (!canScrollTo(child)) { 3256 continue; 3257 } 3258 int position = getPositionByIndex(index); 3259 int rowIndex = mGrid.getRowIndex(position); 3260 if (focusedRow == NO_POSITION) { 3261 focusPosition = position; 3262 newSelected = child; 3263 focusedRow = rowIndex; 3264 } else if (rowIndex == focusedRow) { 3265 if ((moves > 0 && position > focusPosition) 3266 || (moves < 0 && position < focusPosition)) { 3267 focusPosition = position; 3268 newSelected = child; 3269 if (moves > 0) { 3270 moves--; 3271 } else { 3272 moves++; 3273 } 3274 } 3275 } 3276 } 3277 if (newSelected != null) { 3278 if (preventScroll) { 3279 if (hasFocus()) { 3280 mInSelection = true; 3281 newSelected.requestFocus(); 3282 mInSelection = false; 3283 } 3284 mFocusPosition = focusPosition; 3285 mSubFocusPosition = 0; 3286 } else { 3287 scrollToView(newSelected, true); 3288 } 3289 } 3290 return moves; 3291 } 3292 3293 @Override 3294 public void onInitializeAccessibilityNodeInfo(Recycler recycler, State state, 3295 AccessibilityNodeInfoCompat info) { 3296 saveContext(recycler, state); 3297 if (mScrollEnabled && !hasCreatedFirstItem()) { 3298 info.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_BACKWARD); 3299 info.setScrollable(true); 3300 } 3301 if (mScrollEnabled && !hasCreatedLastItem()) { 3302 info.addAction(AccessibilityNodeInfoCompat.ACTION_SCROLL_FORWARD); 3303 info.setScrollable(true); 3304 } 3305 final AccessibilityNodeInfoCompat.CollectionInfoCompat collectionInfo 3306 = AccessibilityNodeInfoCompat.CollectionInfoCompat 3307 .obtain(getRowCountForAccessibility(recycler, state), 3308 getColumnCountForAccessibility(recycler, state), 3309 isLayoutHierarchical(recycler, state), 3310 getSelectionModeForAccessibility(recycler, state)); 3311 info.setCollectionInfo(collectionInfo); 3312 leaveContext(); 3313 } 3314} 3315