package androidx.recyclerview.widget; import android.annotation.SuppressLint; import android.content.Context; import android.graphics.PointF; import android.os.Parcel; import android.os.Parcelable; import android.util.AttributeSet; import android.util.Log; import android.view.View; import android.view.accessibility.AccessibilityEvent; import androidx.annotation.NonNull; import androidx.annotation.RestrictTo; import androidx.recyclerview.widget.ItemTouchHelper; import androidx.recyclerview.widget.RecyclerView; import com.mstar.android.tv.TvLanguage; import java.util.List; /* JADX INFO: loaded from: classes.dex */ public class LinearLayoutManager extends RecyclerView.LayoutManager implements ItemTouchHelper.ViewDropHandler, RecyclerView.SmoothScroller.ScrollVectorProvider { static final boolean DEBUG = false; public static final int HORIZONTAL = 0; public static final int INVALID_OFFSET = Integer.MIN_VALUE; private static final float MAX_SCROLL_FACTOR = 0.33333334f; private static final String TAG = "LinearLayoutManager"; public static final int VERTICAL = 1; final AnchorInfo mAnchorInfo; private int mInitialPrefetchItemCount; private boolean mLastStackFromEnd; private final LayoutChunkResult mLayoutChunkResult; private LayoutState mLayoutState; int mOrientation; OrientationHelper mOrientationHelper; SavedState mPendingSavedState; int mPendingScrollPosition; int mPendingScrollPositionOffset; private boolean mRecycleChildrenOnDetach; private int[] mReusableIntPair; private boolean mReverseLayout; boolean mShouldReverseLayout; private boolean mSmoothScrollbarEnabled; private boolean mStackFromEnd; static class AnchorInfo { int mCoordinate; boolean mLayoutFromEnd; OrientationHelper mOrientationHelper; int mPosition; boolean mValid; AnchorInfo() { reset(); } void assignCoordinateFromPadding() { this.mCoordinate = this.mLayoutFromEnd ? this.mOrientationHelper.getEndAfterPadding() : this.mOrientationHelper.getStartAfterPadding(); } public void assignFromView(View view, int i2) { if (this.mLayoutFromEnd) { this.mCoordinate = this.mOrientationHelper.getDecoratedEnd(view) + this.mOrientationHelper.getTotalSpaceChange(); } else { this.mCoordinate = this.mOrientationHelper.getDecoratedStart(view); } this.mPosition = i2; } public void assignFromViewAndKeepVisibleRect(View view, int i2) { int totalSpaceChange = this.mOrientationHelper.getTotalSpaceChange(); if (totalSpaceChange >= 0) { assignFromView(view, i2); return; } this.mPosition = i2; if (this.mLayoutFromEnd) { int endAfterPadding = (this.mOrientationHelper.getEndAfterPadding() - totalSpaceChange) - this.mOrientationHelper.getDecoratedEnd(view); this.mCoordinate = this.mOrientationHelper.getEndAfterPadding() - endAfterPadding; if (endAfterPadding > 0) { int decoratedMeasurement = this.mCoordinate - this.mOrientationHelper.getDecoratedMeasurement(view); int startAfterPadding = this.mOrientationHelper.getStartAfterPadding(); int iMin = decoratedMeasurement - (startAfterPadding + Math.min(this.mOrientationHelper.getDecoratedStart(view) - startAfterPadding, 0)); if (iMin < 0) { this.mCoordinate += Math.min(endAfterPadding, -iMin); return; } return; } return; } int decoratedStart = this.mOrientationHelper.getDecoratedStart(view); int startAfterPadding2 = decoratedStart - this.mOrientationHelper.getStartAfterPadding(); this.mCoordinate = decoratedStart; if (startAfterPadding2 > 0) { int endAfterPadding2 = (this.mOrientationHelper.getEndAfterPadding() - Math.min(0, (this.mOrientationHelper.getEndAfterPadding() - totalSpaceChange) - this.mOrientationHelper.getDecoratedEnd(view))) - (decoratedStart + this.mOrientationHelper.getDecoratedMeasurement(view)); if (endAfterPadding2 < 0) { this.mCoordinate -= Math.min(startAfterPadding2, -endAfterPadding2); } } } boolean isViewValidAsAnchor(View view, RecyclerView.State state) { RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams(); return !layoutParams.isItemRemoved() && layoutParams.getViewLayoutPosition() >= 0 && layoutParams.getViewLayoutPosition() < state.getItemCount(); } void reset() { this.mPosition = -1; this.mCoordinate = Integer.MIN_VALUE; this.mLayoutFromEnd = false; this.mValid = false; } public String toString() { return "AnchorInfo{mPosition=" + this.mPosition + ", mCoordinate=" + this.mCoordinate + ", mLayoutFromEnd=" + this.mLayoutFromEnd + ", mValid=" + this.mValid + '}'; } } protected static class LayoutChunkResult { public int mConsumed; public boolean mFinished; public boolean mFocusable; public boolean mIgnoreConsumed; protected LayoutChunkResult() { } void resetInternal() { this.mConsumed = 0; this.mFinished = false; this.mIgnoreConsumed = false; this.mFocusable = false; } } static class LayoutState { static final int INVALID_LAYOUT = Integer.MIN_VALUE; static final int ITEM_DIRECTION_HEAD = -1; static final int ITEM_DIRECTION_TAIL = 1; static final int LAYOUT_END = 1; static final int LAYOUT_START = -1; static final int SCROLLING_OFFSET_NaN = Integer.MIN_VALUE; static final String TAG = "LLM#LayoutState"; int mAvailable; int mCurrentPosition; boolean mInfinite; int mItemDirection; int mLastScrollDelta; int mLayoutDirection; int mOffset; int mScrollingOffset; boolean mRecycle = true; int mExtraFillSpace = 0; int mNoRecycleSpace = 0; boolean mIsPreLayout = false; List mScrapList = null; LayoutState() { } private View nextViewFromScrapList() { int size = this.mScrapList.size(); for (int i2 = 0; i2 < size; i2++) { View view = this.mScrapList.get(i2).itemView; RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams(); if (!layoutParams.isItemRemoved() && this.mCurrentPosition == layoutParams.getViewLayoutPosition()) { assignPositionFromScrapList(view); return view; } } return null; } public void assignPositionFromScrapList() { assignPositionFromScrapList(null); } boolean hasMore(RecyclerView.State state) { int i2 = this.mCurrentPosition; return i2 >= 0 && i2 < state.getItemCount(); } void log() { Log.d(TAG, "avail:" + this.mAvailable + ", ind:" + this.mCurrentPosition + ", dir:" + this.mItemDirection + ", offset:" + this.mOffset + ", layoutDir:" + this.mLayoutDirection); } View next(RecyclerView.Recycler recycler) { if (this.mScrapList != null) { return nextViewFromScrapList(); } View viewForPosition = recycler.getViewForPosition(this.mCurrentPosition); this.mCurrentPosition += this.mItemDirection; return viewForPosition; } public View nextViewInLimitedList(View view) { int viewLayoutPosition; int size = this.mScrapList.size(); View view2 = null; int i2 = Integer.MAX_VALUE; for (int i3 = 0; i3 < size; i3++) { View view3 = this.mScrapList.get(i3).itemView; RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view3.getLayoutParams(); if (view3 != view && !layoutParams.isItemRemoved() && (viewLayoutPosition = (layoutParams.getViewLayoutPosition() - this.mCurrentPosition) * this.mItemDirection) >= 0 && viewLayoutPosition < i2) { view2 = view3; if (viewLayoutPosition == 0) { break; } i2 = viewLayoutPosition; } } return view2; } public void assignPositionFromScrapList(View view) { View viewNextViewInLimitedList = nextViewInLimitedList(view); if (viewNextViewInLimitedList == null) { this.mCurrentPosition = -1; } else { this.mCurrentPosition = ((RecyclerView.LayoutParams) viewNextViewInLimitedList.getLayoutParams()).getViewLayoutPosition(); } } } @SuppressLint({"BanParcelableUsage"}) @RestrictTo({RestrictTo.Scope.LIBRARY}) public static class SavedState implements Parcelable { public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { // from class: androidx.recyclerview.widget.LinearLayoutManager.SavedState.1 /* JADX WARN: Can't rename method to resolve collision */ @Override // android.os.Parcelable.Creator public SavedState createFromParcel(Parcel parcel) { return new SavedState(parcel); } /* JADX WARN: Can't rename method to resolve collision */ @Override // android.os.Parcelable.Creator public SavedState[] newArray(int i2) { return new SavedState[i2]; } }; boolean mAnchorLayoutFromEnd; int mAnchorOffset; int mAnchorPosition; public SavedState() { } @Override // android.os.Parcelable public int describeContents() { return 0; } boolean hasValidAnchor() { return this.mAnchorPosition >= 0; } void invalidateAnchor() { this.mAnchorPosition = -1; } @Override // android.os.Parcelable public void writeToParcel(Parcel parcel, int i2) { parcel.writeInt(this.mAnchorPosition); parcel.writeInt(this.mAnchorOffset); parcel.writeInt(this.mAnchorLayoutFromEnd ? 1 : 0); } SavedState(Parcel parcel) { this.mAnchorPosition = parcel.readInt(); this.mAnchorOffset = parcel.readInt(); this.mAnchorLayoutFromEnd = parcel.readInt() == 1; } public SavedState(SavedState savedState) { this.mAnchorPosition = savedState.mAnchorPosition; this.mAnchorOffset = savedState.mAnchorOffset; this.mAnchorLayoutFromEnd = savedState.mAnchorLayoutFromEnd; } } public LinearLayoutManager(Context context) { this(context, 1, false); } private int computeScrollExtent(RecyclerView.State state) { if (getChildCount() == 0) { return 0; } ensureLayoutState(); return ScrollbarHelper.computeScrollExtent(state, this.mOrientationHelper, findFirstVisibleChildClosestToStart(!this.mSmoothScrollbarEnabled, true), findFirstVisibleChildClosestToEnd(!this.mSmoothScrollbarEnabled, true), this, this.mSmoothScrollbarEnabled); } private int computeScrollOffset(RecyclerView.State state) { if (getChildCount() == 0) { return 0; } ensureLayoutState(); return ScrollbarHelper.computeScrollOffset(state, this.mOrientationHelper, findFirstVisibleChildClosestToStart(!this.mSmoothScrollbarEnabled, true), findFirstVisibleChildClosestToEnd(!this.mSmoothScrollbarEnabled, true), this, this.mSmoothScrollbarEnabled, this.mShouldReverseLayout); } private int computeScrollRange(RecyclerView.State state) { if (getChildCount() == 0) { return 0; } ensureLayoutState(); return ScrollbarHelper.computeScrollRange(state, this.mOrientationHelper, findFirstVisibleChildClosestToStart(!this.mSmoothScrollbarEnabled, true), findFirstVisibleChildClosestToEnd(!this.mSmoothScrollbarEnabled, true), this, this.mSmoothScrollbarEnabled); } private View findFirstPartiallyOrCompletelyInvisibleChild() { return findOnePartiallyOrCompletelyInvisibleChild(0, getChildCount()); } private View findLastPartiallyOrCompletelyInvisibleChild() { return findOnePartiallyOrCompletelyInvisibleChild(getChildCount() - 1, -1); } private View findPartiallyOrCompletelyInvisibleChildClosestToEnd() { return this.mShouldReverseLayout ? findFirstPartiallyOrCompletelyInvisibleChild() : findLastPartiallyOrCompletelyInvisibleChild(); } private View findPartiallyOrCompletelyInvisibleChildClosestToStart() { return this.mShouldReverseLayout ? findLastPartiallyOrCompletelyInvisibleChild() : findFirstPartiallyOrCompletelyInvisibleChild(); } private int fixLayoutEndGap(int i2, RecyclerView.Recycler recycler, RecyclerView.State state, boolean z2) { int endAfterPadding; int endAfterPadding2 = this.mOrientationHelper.getEndAfterPadding() - i2; if (endAfterPadding2 <= 0) { return 0; } int i3 = -scrollBy(-endAfterPadding2, recycler, state); int i4 = i2 + i3; if (!z2 || (endAfterPadding = this.mOrientationHelper.getEndAfterPadding() - i4) <= 0) { return i3; } this.mOrientationHelper.offsetChildren(endAfterPadding); return endAfterPadding + i3; } private int fixLayoutStartGap(int i2, RecyclerView.Recycler recycler, RecyclerView.State state, boolean z2) { int startAfterPadding; int startAfterPadding2 = i2 - this.mOrientationHelper.getStartAfterPadding(); if (startAfterPadding2 <= 0) { return 0; } int i3 = -scrollBy(startAfterPadding2, recycler, state); int i4 = i2 + i3; if (!z2 || (startAfterPadding = i4 - this.mOrientationHelper.getStartAfterPadding()) <= 0) { return i3; } this.mOrientationHelper.offsetChildren(-startAfterPadding); return i3 - startAfterPadding; } private View getChildClosestToEnd() { return getChildAt(this.mShouldReverseLayout ? 0 : getChildCount() - 1); } private View getChildClosestToStart() { return getChildAt(this.mShouldReverseLayout ? getChildCount() - 1 : 0); } private void layoutForPredictiveAnimations(RecyclerView.Recycler recycler, RecyclerView.State state, int i2, int i3) { if (!state.willRunPredictiveAnimations() || getChildCount() == 0 || state.isPreLayout() || !supportsPredictiveItemAnimations()) { return; } List scrapList = recycler.getScrapList(); int size = scrapList.size(); int position = getPosition(getChildAt(0)); int decoratedMeasurement = 0; int decoratedMeasurement2 = 0; for (int i4 = 0; i4 < size; i4++) { RecyclerView.ViewHolder viewHolder = scrapList.get(i4); if (!viewHolder.isRemoved()) { if ((viewHolder.getLayoutPosition() < position) != this.mShouldReverseLayout) { decoratedMeasurement += this.mOrientationHelper.getDecoratedMeasurement(viewHolder.itemView); } else { decoratedMeasurement2 += this.mOrientationHelper.getDecoratedMeasurement(viewHolder.itemView); } } } this.mLayoutState.mScrapList = scrapList; if (decoratedMeasurement > 0) { updateLayoutStateToFillStart(getPosition(getChildClosestToStart()), i2); LayoutState layoutState = this.mLayoutState; layoutState.mExtraFillSpace = decoratedMeasurement; layoutState.mAvailable = 0; layoutState.assignPositionFromScrapList(); fill(recycler, this.mLayoutState, state, false); } if (decoratedMeasurement2 > 0) { updateLayoutStateToFillEnd(getPosition(getChildClosestToEnd()), i3); LayoutState layoutState2 = this.mLayoutState; layoutState2.mExtraFillSpace = decoratedMeasurement2; layoutState2.mAvailable = 0; layoutState2.assignPositionFromScrapList(); fill(recycler, this.mLayoutState, state, false); } this.mLayoutState.mScrapList = null; } private void logChildren() { Log.d(TAG, "internal representation of views on the screen"); for (int i2 = 0; i2 < getChildCount(); i2++) { View childAt = getChildAt(i2); Log.d(TAG, "item " + getPosition(childAt) + ", coord:" + this.mOrientationHelper.getDecoratedStart(childAt)); } Log.d(TAG, "=============="); } private void recycleByLayoutState(RecyclerView.Recycler recycler, LayoutState layoutState) { if (!layoutState.mRecycle || layoutState.mInfinite) { return; } int i2 = layoutState.mScrollingOffset; int i3 = layoutState.mNoRecycleSpace; if (layoutState.mLayoutDirection == -1) { recycleViewsFromEnd(recycler, i2, i3); } else { recycleViewsFromStart(recycler, i2, i3); } } private void recycleChildren(RecyclerView.Recycler recycler, int i2, int i3) { if (i2 == i3) { return; } if (i3 <= i2) { while (i2 > i3) { removeAndRecycleViewAt(i2, recycler); i2--; } } else { for (int i4 = i3 - 1; i4 >= i2; i4--) { removeAndRecycleViewAt(i4, recycler); } } } private void recycleViewsFromEnd(RecyclerView.Recycler recycler, int i2, int i3) { int childCount = getChildCount(); if (i2 < 0) { return; } int end = (this.mOrientationHelper.getEnd() - i2) + i3; if (this.mShouldReverseLayout) { for (int i4 = 0; i4 < childCount; i4++) { View childAt = getChildAt(i4); if (this.mOrientationHelper.getDecoratedStart(childAt) < end || this.mOrientationHelper.getTransformedStartWithDecoration(childAt) < end) { recycleChildren(recycler, 0, i4); return; } } return; } int i5 = childCount - 1; for (int i6 = i5; i6 >= 0; i6--) { View childAt2 = getChildAt(i6); if (this.mOrientationHelper.getDecoratedStart(childAt2) < end || this.mOrientationHelper.getTransformedStartWithDecoration(childAt2) < end) { recycleChildren(recycler, i5, i6); return; } } } private void recycleViewsFromStart(RecyclerView.Recycler recycler, int i2, int i3) { if (i2 < 0) { return; } int i4 = i2 - i3; int childCount = getChildCount(); if (!this.mShouldReverseLayout) { for (int i5 = 0; i5 < childCount; i5++) { View childAt = getChildAt(i5); if (this.mOrientationHelper.getDecoratedEnd(childAt) > i4 || this.mOrientationHelper.getTransformedEndWithDecoration(childAt) > i4) { recycleChildren(recycler, 0, i5); return; } } return; } int i6 = childCount - 1; for (int i7 = i6; i7 >= 0; i7--) { View childAt2 = getChildAt(i7); if (this.mOrientationHelper.getDecoratedEnd(childAt2) > i4 || this.mOrientationHelper.getTransformedEndWithDecoration(childAt2) > i4) { recycleChildren(recycler, i6, i7); return; } } } private void resolveShouldLayoutReverse() { if (this.mOrientation == 1 || !isLayoutRTL()) { this.mShouldReverseLayout = this.mReverseLayout; } else { this.mShouldReverseLayout = !this.mReverseLayout; } } private boolean updateAnchorFromChildren(RecyclerView.Recycler recycler, RecyclerView.State state, AnchorInfo anchorInfo) { View viewFindReferenceChild; boolean z2 = false; if (getChildCount() == 0) { return false; } View focusedChild = getFocusedChild(); if (focusedChild != null && anchorInfo.isViewValidAsAnchor(focusedChild, state)) { anchorInfo.assignFromViewAndKeepVisibleRect(focusedChild, getPosition(focusedChild)); return true; } boolean z3 = this.mLastStackFromEnd; boolean z4 = this.mStackFromEnd; if (z3 != z4 || (viewFindReferenceChild = findReferenceChild(recycler, state, anchorInfo.mLayoutFromEnd, z4)) == null) { return false; } anchorInfo.assignFromView(viewFindReferenceChild, getPosition(viewFindReferenceChild)); if (!state.isPreLayout() && supportsPredictiveItemAnimations()) { int decoratedStart = this.mOrientationHelper.getDecoratedStart(viewFindReferenceChild); int decoratedEnd = this.mOrientationHelper.getDecoratedEnd(viewFindReferenceChild); int startAfterPadding = this.mOrientationHelper.getStartAfterPadding(); int endAfterPadding = this.mOrientationHelper.getEndAfterPadding(); boolean z5 = decoratedEnd <= startAfterPadding && decoratedStart < startAfterPadding; if (decoratedStart >= endAfterPadding && decoratedEnd > endAfterPadding) { z2 = true; } if (z5 || z2) { if (anchorInfo.mLayoutFromEnd) { startAfterPadding = endAfterPadding; } anchorInfo.mCoordinate = startAfterPadding; } } return true; } private boolean updateAnchorFromPendingData(RecyclerView.State state, AnchorInfo anchorInfo) { int i2; if (!state.isPreLayout() && (i2 = this.mPendingScrollPosition) != -1) { if (i2 >= 0 && i2 < state.getItemCount()) { anchorInfo.mPosition = this.mPendingScrollPosition; SavedState savedState = this.mPendingSavedState; if (savedState != null && savedState.hasValidAnchor()) { boolean z2 = this.mPendingSavedState.mAnchorLayoutFromEnd; anchorInfo.mLayoutFromEnd = z2; if (z2) { anchorInfo.mCoordinate = this.mOrientationHelper.getEndAfterPadding() - this.mPendingSavedState.mAnchorOffset; } else { anchorInfo.mCoordinate = this.mOrientationHelper.getStartAfterPadding() + this.mPendingSavedState.mAnchorOffset; } return true; } if (this.mPendingScrollPositionOffset != Integer.MIN_VALUE) { boolean z3 = this.mShouldReverseLayout; anchorInfo.mLayoutFromEnd = z3; if (z3) { anchorInfo.mCoordinate = this.mOrientationHelper.getEndAfterPadding() - this.mPendingScrollPositionOffset; } else { anchorInfo.mCoordinate = this.mOrientationHelper.getStartAfterPadding() + this.mPendingScrollPositionOffset; } return true; } View viewFindViewByPosition = findViewByPosition(this.mPendingScrollPosition); if (viewFindViewByPosition == null) { if (getChildCount() > 0) { anchorInfo.mLayoutFromEnd = (this.mPendingScrollPosition < getPosition(getChildAt(0))) == this.mShouldReverseLayout; } anchorInfo.assignCoordinateFromPadding(); } else { if (this.mOrientationHelper.getDecoratedMeasurement(viewFindViewByPosition) > this.mOrientationHelper.getTotalSpace()) { anchorInfo.assignCoordinateFromPadding(); return true; } if (this.mOrientationHelper.getDecoratedStart(viewFindViewByPosition) - this.mOrientationHelper.getStartAfterPadding() < 0) { anchorInfo.mCoordinate = this.mOrientationHelper.getStartAfterPadding(); anchorInfo.mLayoutFromEnd = false; return true; } if (this.mOrientationHelper.getEndAfterPadding() - this.mOrientationHelper.getDecoratedEnd(viewFindViewByPosition) < 0) { anchorInfo.mCoordinate = this.mOrientationHelper.getEndAfterPadding(); anchorInfo.mLayoutFromEnd = true; return true; } anchorInfo.mCoordinate = anchorInfo.mLayoutFromEnd ? this.mOrientationHelper.getDecoratedEnd(viewFindViewByPosition) + this.mOrientationHelper.getTotalSpaceChange() : this.mOrientationHelper.getDecoratedStart(viewFindViewByPosition); } return true; } this.mPendingScrollPosition = -1; this.mPendingScrollPositionOffset = Integer.MIN_VALUE; } return false; } private void updateAnchorInfoForLayout(RecyclerView.Recycler recycler, RecyclerView.State state, AnchorInfo anchorInfo) { if (updateAnchorFromPendingData(state, anchorInfo) || updateAnchorFromChildren(recycler, state, anchorInfo)) { return; } anchorInfo.assignCoordinateFromPadding(); anchorInfo.mPosition = this.mStackFromEnd ? state.getItemCount() - 1 : 0; } private void updateLayoutState(int i2, int i3, boolean z2, RecyclerView.State state) { int startAfterPadding; this.mLayoutState.mInfinite = resolveIsInfinite(); this.mLayoutState.mLayoutDirection = i2; int[] iArr = this.mReusableIntPair; iArr[0] = 0; iArr[1] = 0; calculateExtraLayoutSpace(state, iArr); int iMax = Math.max(0, this.mReusableIntPair[0]); int iMax2 = Math.max(0, this.mReusableIntPair[1]); boolean z3 = i2 == 1; LayoutState layoutState = this.mLayoutState; int i4 = z3 ? iMax2 : iMax; layoutState.mExtraFillSpace = i4; if (!z3) { iMax = iMax2; } layoutState.mNoRecycleSpace = iMax; if (z3) { layoutState.mExtraFillSpace = i4 + this.mOrientationHelper.getEndPadding(); View childClosestToEnd = getChildClosestToEnd(); LayoutState layoutState2 = this.mLayoutState; layoutState2.mItemDirection = this.mShouldReverseLayout ? -1 : 1; int position = getPosition(childClosestToEnd); LayoutState layoutState3 = this.mLayoutState; layoutState2.mCurrentPosition = position + layoutState3.mItemDirection; layoutState3.mOffset = this.mOrientationHelper.getDecoratedEnd(childClosestToEnd); startAfterPadding = this.mOrientationHelper.getDecoratedEnd(childClosestToEnd) - this.mOrientationHelper.getEndAfterPadding(); } else { View childClosestToStart = getChildClosestToStart(); this.mLayoutState.mExtraFillSpace += this.mOrientationHelper.getStartAfterPadding(); LayoutState layoutState4 = this.mLayoutState; layoutState4.mItemDirection = this.mShouldReverseLayout ? 1 : -1; int position2 = getPosition(childClosestToStart); LayoutState layoutState5 = this.mLayoutState; layoutState4.mCurrentPosition = position2 + layoutState5.mItemDirection; layoutState5.mOffset = this.mOrientationHelper.getDecoratedStart(childClosestToStart); startAfterPadding = (-this.mOrientationHelper.getDecoratedStart(childClosestToStart)) + this.mOrientationHelper.getStartAfterPadding(); } LayoutState layoutState6 = this.mLayoutState; layoutState6.mAvailable = i3; if (z2) { layoutState6.mAvailable = i3 - startAfterPadding; } layoutState6.mScrollingOffset = startAfterPadding; } private void updateLayoutStateToFillEnd(AnchorInfo anchorInfo) { updateLayoutStateToFillEnd(anchorInfo.mPosition, anchorInfo.mCoordinate); } private void updateLayoutStateToFillStart(AnchorInfo anchorInfo) { updateLayoutStateToFillStart(anchorInfo.mPosition, anchorInfo.mCoordinate); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void assertNotInLayoutOrScroll(String str) { if (this.mPendingSavedState == null) { super.assertNotInLayoutOrScroll(str); } } protected void calculateExtraLayoutSpace(@NonNull RecyclerView.State state, @NonNull int[] iArr) { int i2; int extraLayoutSpace = getExtraLayoutSpace(state); if (this.mLayoutState.mLayoutDirection == -1) { i2 = 0; } else { i2 = extraLayoutSpace; extraLayoutSpace = 0; } iArr[0] = extraLayoutSpace; iArr[1] = i2; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public boolean canScrollHorizontally() { return this.mOrientation == 0; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public boolean canScrollVertically() { return this.mOrientation == 1; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void collectAdjacentPrefetchPositions(int i2, int i3, RecyclerView.State state, RecyclerView.LayoutManager.LayoutPrefetchRegistry layoutPrefetchRegistry) { if (this.mOrientation != 0) { i2 = i3; } if (getChildCount() == 0 || i2 == 0) { return; } ensureLayoutState(); updateLayoutState(i2 > 0 ? 1 : -1, Math.abs(i2), true, state); collectPrefetchPositionsForLayoutState(state, this.mLayoutState, layoutPrefetchRegistry); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void collectInitialPrefetchPositions(int i2, RecyclerView.LayoutManager.LayoutPrefetchRegistry layoutPrefetchRegistry) { boolean z2; int i3; SavedState savedState = this.mPendingSavedState; if (savedState == null || !savedState.hasValidAnchor()) { resolveShouldLayoutReverse(); z2 = this.mShouldReverseLayout; i3 = this.mPendingScrollPosition; if (i3 == -1) { i3 = z2 ? i2 - 1 : 0; } } else { SavedState savedState2 = this.mPendingSavedState; z2 = savedState2.mAnchorLayoutFromEnd; i3 = savedState2.mAnchorPosition; } int i4 = z2 ? -1 : 1; for (int i5 = 0; i5 < this.mInitialPrefetchItemCount && i3 >= 0 && i3 < i2; i5++) { layoutPrefetchRegistry.addPosition(i3, 0); i3 += i4; } } void collectPrefetchPositionsForLayoutState(RecyclerView.State state, LayoutState layoutState, RecyclerView.LayoutManager.LayoutPrefetchRegistry layoutPrefetchRegistry) { int i2 = layoutState.mCurrentPosition; if (i2 < 0 || i2 >= state.getItemCount()) { return; } layoutPrefetchRegistry.addPosition(i2, Math.max(0, layoutState.mScrollingOffset)); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int computeHorizontalScrollExtent(RecyclerView.State state) { return computeScrollExtent(state); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int computeHorizontalScrollOffset(RecyclerView.State state) { return computeScrollOffset(state); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int computeHorizontalScrollRange(RecyclerView.State state) { return computeScrollRange(state); } @Override // androidx.recyclerview.widget.RecyclerView.SmoothScroller.ScrollVectorProvider public PointF computeScrollVectorForPosition(int i2) { if (getChildCount() == 0) { return null; } int i3 = (i2 < getPosition(getChildAt(0))) != this.mShouldReverseLayout ? -1 : 1; return this.mOrientation == 0 ? new PointF(i3, 0.0f) : new PointF(0.0f, i3); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int computeVerticalScrollExtent(RecyclerView.State state) { return computeScrollExtent(state); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int computeVerticalScrollOffset(RecyclerView.State state) { return computeScrollOffset(state); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int computeVerticalScrollRange(RecyclerView.State state) { return computeScrollRange(state); } int convertFocusDirectionToLayoutDirection(int i2) { return i2 != 1 ? i2 != 2 ? i2 != 17 ? i2 != 33 ? i2 != 66 ? (i2 == 130 && this.mOrientation == 1) ? 1 : Integer.MIN_VALUE : this.mOrientation == 0 ? 1 : Integer.MIN_VALUE : this.mOrientation == 1 ? -1 : Integer.MIN_VALUE : this.mOrientation == 0 ? -1 : Integer.MIN_VALUE : (this.mOrientation != 1 && isLayoutRTL()) ? -1 : 1 : (this.mOrientation != 1 && isLayoutRTL()) ? 1 : -1; } LayoutState createLayoutState() { return new LayoutState(); } void ensureLayoutState() { if (this.mLayoutState == null) { this.mLayoutState = createLayoutState(); } } int fill(RecyclerView.Recycler recycler, LayoutState layoutState, RecyclerView.State state, boolean z2) { int i2 = layoutState.mAvailable; int i3 = layoutState.mScrollingOffset; if (i3 != Integer.MIN_VALUE) { if (i2 < 0) { layoutState.mScrollingOffset = i3 + i2; } recycleByLayoutState(recycler, layoutState); } int i4 = layoutState.mAvailable + layoutState.mExtraFillSpace; LayoutChunkResult layoutChunkResult = this.mLayoutChunkResult; while (true) { if ((!layoutState.mInfinite && i4 <= 0) || !layoutState.hasMore(state)) { break; } layoutChunkResult.resetInternal(); layoutChunk(recycler, state, layoutState, layoutChunkResult); if (!layoutChunkResult.mFinished) { layoutState.mOffset += layoutChunkResult.mConsumed * layoutState.mLayoutDirection; if (!layoutChunkResult.mIgnoreConsumed || layoutState.mScrapList != null || !state.isPreLayout()) { int i5 = layoutState.mAvailable; int i6 = layoutChunkResult.mConsumed; layoutState.mAvailable = i5 - i6; i4 -= i6; } int i7 = layoutState.mScrollingOffset; if (i7 != Integer.MIN_VALUE) { int i8 = i7 + layoutChunkResult.mConsumed; layoutState.mScrollingOffset = i8; int i9 = layoutState.mAvailable; if (i9 < 0) { layoutState.mScrollingOffset = i8 + i9; } recycleByLayoutState(recycler, layoutState); } if (z2 && layoutChunkResult.mFocusable) { break; } } else { break; } } return i2 - layoutState.mAvailable; } public int findFirstCompletelyVisibleItemPosition() { View viewFindOneVisibleChild = findOneVisibleChild(0, getChildCount(), true, false); if (viewFindOneVisibleChild == null) { return -1; } return getPosition(viewFindOneVisibleChild); } View findFirstVisibleChildClosestToEnd(boolean z2, boolean z3) { return this.mShouldReverseLayout ? findOneVisibleChild(0, getChildCount(), z2, z3) : findOneVisibleChild(getChildCount() - 1, -1, z2, z3); } View findFirstVisibleChildClosestToStart(boolean z2, boolean z3) { return this.mShouldReverseLayout ? findOneVisibleChild(getChildCount() - 1, -1, z2, z3) : findOneVisibleChild(0, getChildCount(), z2, z3); } public int findFirstVisibleItemPosition() { View viewFindOneVisibleChild = findOneVisibleChild(0, getChildCount(), false, true); if (viewFindOneVisibleChild == null) { return -1; } return getPosition(viewFindOneVisibleChild); } public int findLastCompletelyVisibleItemPosition() { View viewFindOneVisibleChild = findOneVisibleChild(getChildCount() - 1, -1, true, false); if (viewFindOneVisibleChild == null) { return -1; } return getPosition(viewFindOneVisibleChild); } public int findLastVisibleItemPosition() { View viewFindOneVisibleChild = findOneVisibleChild(getChildCount() - 1, -1, false, true); if (viewFindOneVisibleChild == null) { return -1; } return getPosition(viewFindOneVisibleChild); } View findOnePartiallyOrCompletelyInvisibleChild(int i2, int i3) { int i4; int i5; ensureLayoutState(); if (i3 <= i2 && i3 >= i2) { return getChildAt(i2); } if (this.mOrientationHelper.getDecoratedStart(getChildAt(i2)) < this.mOrientationHelper.getStartAfterPadding()) { i4 = 16644; i5 = 16388; } else { i4 = 4161; i5 = 4097; } return this.mOrientation == 0 ? this.mHorizontalBoundCheck.findOneViewWithinBoundFlags(i2, i3, i4, i5) : this.mVerticalBoundCheck.findOneViewWithinBoundFlags(i2, i3, i4, i5); } View findOneVisibleChild(int i2, int i3, boolean z2, boolean z3) { ensureLayoutState(); int i4 = TvLanguage.MOSSI; int i5 = z2 ? 24579 : 320; if (!z3) { i4 = 0; } return this.mOrientation == 0 ? this.mHorizontalBoundCheck.findOneViewWithinBoundFlags(i2, i3, i5, i4) : this.mVerticalBoundCheck.findOneViewWithinBoundFlags(i2, i3, i5, i4); } /* JADX WARN: Removed duplicated region for block: B:33:0x0073 */ /* JADX WARN: Removed duplicated region for block: B:35:0x0077 */ /* Code decompiled incorrectly, please refer to instructions dump. To view partially-correct add '--show-bad-code' argument */ android.view.View findReferenceChild(androidx.recyclerview.widget.RecyclerView.Recycler r17, androidx.recyclerview.widget.RecyclerView.State r18, boolean r19, boolean r20) { /* r16 = this; r0 = r16 r16.ensureLayoutState() int r1 = r16.getChildCount() r2 = 0 r3 = 1 if (r20 == 0) goto L15 int r1 = r16.getChildCount() int r1 = r1 - r3 r4 = -1 r5 = r4 goto L18 L15: r4 = r1 r1 = r2 r5 = r3 L18: int r6 = r18.getItemCount() androidx.recyclerview.widget.OrientationHelper r7 = r0.mOrientationHelper int r7 = r7.getStartAfterPadding() androidx.recyclerview.widget.OrientationHelper r8 = r0.mOrientationHelper int r8 = r8.getEndAfterPadding() r9 = 0 r10 = r9 r11 = r10 L2b: if (r1 == r4) goto L7a android.view.View r12 = r0.getChildAt(r1) int r13 = r0.getPosition(r12) androidx.recyclerview.widget.OrientationHelper r14 = r0.mOrientationHelper int r14 = r14.getDecoratedStart(r12) androidx.recyclerview.widget.OrientationHelper r15 = r0.mOrientationHelper int r15 = r15.getDecoratedEnd(r12) if (r13 < 0) goto L78 if (r13 >= r6) goto L78 android.view.ViewGroup$LayoutParams r13 = r12.getLayoutParams() androidx.recyclerview.widget.RecyclerView$LayoutParams r13 = (androidx.recyclerview.widget.RecyclerView.LayoutParams) r13 boolean r13 = r13.isItemRemoved() if (r13 == 0) goto L55 if (r11 != 0) goto L78 r11 = r12 goto L78 L55: if (r15 > r7) goto L5b if (r14 >= r7) goto L5b r13 = r3 goto L5c L5b: r13 = r2 L5c: if (r14 < r8) goto L62 if (r15 <= r8) goto L62 r14 = r3 goto L63 L62: r14 = r2 L63: if (r13 != 0) goto L69 if (r14 == 0) goto L68 goto L69 L68: return r12 L69: if (r19 == 0) goto L71 if (r14 == 0) goto L6e goto L73 L6e: if (r9 != 0) goto L78 goto L77 L71: if (r13 == 0) goto L75 L73: r10 = r12 goto L78 L75: if (r9 != 0) goto L78 L77: r9 = r12 L78: int r1 = r1 + r5 goto L2b L7a: if (r9 == 0) goto L7d goto L82 L7d: if (r10 == 0) goto L81 r9 = r10 goto L82 L81: r9 = r11 L82: return r9 */ throw new UnsupportedOperationException("Method not decompiled: androidx.recyclerview.widget.LinearLayoutManager.findReferenceChild(androidx.recyclerview.widget.RecyclerView$Recycler, androidx.recyclerview.widget.RecyclerView$State, boolean, boolean):android.view.View"); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public View findViewByPosition(int i2) { int childCount = getChildCount(); if (childCount == 0) { return null; } int position = i2 - getPosition(getChildAt(0)); if (position >= 0 && position < childCount) { View childAt = getChildAt(position); if (getPosition(childAt) == i2) { return childAt; } } return super.findViewByPosition(i2); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public RecyclerView.LayoutParams generateDefaultLayoutParams() { return new RecyclerView.LayoutParams(-2, -2); } @Deprecated protected int getExtraLayoutSpace(RecyclerView.State state) { if (state.hasTargetScrollPosition()) { return this.mOrientationHelper.getTotalSpace(); } return 0; } public int getInitialPrefetchItemCount() { return this.mInitialPrefetchItemCount; } public int getOrientation() { return this.mOrientation; } public boolean getRecycleChildrenOnDetach() { return this.mRecycleChildrenOnDetach; } public boolean getReverseLayout() { return this.mReverseLayout; } public boolean getStackFromEnd() { return this.mStackFromEnd; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public boolean isAutoMeasureEnabled() { return true; } protected boolean isLayoutRTL() { return getLayoutDirection() == 1; } public boolean isSmoothScrollbarEnabled() { return this.mSmoothScrollbarEnabled; } void layoutChunk(RecyclerView.Recycler recycler, RecyclerView.State state, LayoutState layoutState, LayoutChunkResult layoutChunkResult) { int i2; int i3; int i4; int paddingLeft; int decoratedMeasurementInOther; View next = layoutState.next(recycler); if (next == null) { layoutChunkResult.mFinished = true; return; } RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) next.getLayoutParams(); if (layoutState.mScrapList == null) { if (this.mShouldReverseLayout == (layoutState.mLayoutDirection == -1)) { addView(next); } else { addView(next, 0); } } else { if (this.mShouldReverseLayout == (layoutState.mLayoutDirection == -1)) { addDisappearingView(next); } else { addDisappearingView(next, 0); } } measureChildWithMargins(next, 0, 0); layoutChunkResult.mConsumed = this.mOrientationHelper.getDecoratedMeasurement(next); if (this.mOrientation == 1) { if (isLayoutRTL()) { decoratedMeasurementInOther = getWidth() - getPaddingRight(); paddingLeft = decoratedMeasurementInOther - this.mOrientationHelper.getDecoratedMeasurementInOther(next); } else { paddingLeft = getPaddingLeft(); decoratedMeasurementInOther = this.mOrientationHelper.getDecoratedMeasurementInOther(next) + paddingLeft; } if (layoutState.mLayoutDirection == -1) { int i5 = layoutState.mOffset; i4 = i5; i3 = decoratedMeasurementInOther; i2 = i5 - layoutChunkResult.mConsumed; } else { int i6 = layoutState.mOffset; i2 = i6; i3 = decoratedMeasurementInOther; i4 = layoutChunkResult.mConsumed + i6; } } else { int paddingTop = getPaddingTop(); int decoratedMeasurementInOther2 = this.mOrientationHelper.getDecoratedMeasurementInOther(next) + paddingTop; if (layoutState.mLayoutDirection == -1) { int i7 = layoutState.mOffset; i3 = i7; i2 = paddingTop; i4 = decoratedMeasurementInOther2; paddingLeft = i7 - layoutChunkResult.mConsumed; } else { int i8 = layoutState.mOffset; i2 = paddingTop; i3 = layoutChunkResult.mConsumed + i8; i4 = decoratedMeasurementInOther2; paddingLeft = i8; } } layoutDecoratedWithMargins(next, paddingLeft, i2, i3, i4); if (layoutParams.isItemRemoved() || layoutParams.isItemChanged()) { layoutChunkResult.mIgnoreConsumed = true; } layoutChunkResult.mFocusable = next.hasFocusable(); } void onAnchorReady(RecyclerView.Recycler recycler, RecyclerView.State state, AnchorInfo anchorInfo, int i2) { } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void onDetachedFromWindow(RecyclerView recyclerView, RecyclerView.Recycler recycler) { super.onDetachedFromWindow(recyclerView, recycler); if (this.mRecycleChildrenOnDetach) { removeAndRecycleAllViews(recycler); recycler.clear(); } } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public View onFocusSearchFailed(View view, int i2, RecyclerView.Recycler recycler, RecyclerView.State state) { int iConvertFocusDirectionToLayoutDirection; resolveShouldLayoutReverse(); if (getChildCount() == 0 || (iConvertFocusDirectionToLayoutDirection = convertFocusDirectionToLayoutDirection(i2)) == Integer.MIN_VALUE) { return null; } ensureLayoutState(); updateLayoutState(iConvertFocusDirectionToLayoutDirection, (int) (this.mOrientationHelper.getTotalSpace() * MAX_SCROLL_FACTOR), false, state); LayoutState layoutState = this.mLayoutState; layoutState.mScrollingOffset = Integer.MIN_VALUE; layoutState.mRecycle = false; fill(recycler, layoutState, state, true); View viewFindPartiallyOrCompletelyInvisibleChildClosestToStart = iConvertFocusDirectionToLayoutDirection == -1 ? findPartiallyOrCompletelyInvisibleChildClosestToStart() : findPartiallyOrCompletelyInvisibleChildClosestToEnd(); View childClosestToStart = iConvertFocusDirectionToLayoutDirection == -1 ? getChildClosestToStart() : getChildClosestToEnd(); if (!childClosestToStart.hasFocusable()) { return viewFindPartiallyOrCompletelyInvisibleChildClosestToStart; } if (viewFindPartiallyOrCompletelyInvisibleChildClosestToStart == null) { return null; } return childClosestToStart; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void onInitializeAccessibilityEvent(AccessibilityEvent accessibilityEvent) { super.onInitializeAccessibilityEvent(accessibilityEvent); if (getChildCount() > 0) { accessibilityEvent.setFromIndex(findFirstVisibleItemPosition()); accessibilityEvent.setToIndex(findLastVisibleItemPosition()); } } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) { int i2; int i3; int i4; int i5; int iFixLayoutEndGap; int i6; View viewFindViewByPosition; int decoratedStart; int endAfterPadding; int i7 = -1; if (!(this.mPendingSavedState == null && this.mPendingScrollPosition == -1) && state.getItemCount() == 0) { removeAndRecycleAllViews(recycler); return; } SavedState savedState = this.mPendingSavedState; if (savedState != null && savedState.hasValidAnchor()) { this.mPendingScrollPosition = this.mPendingSavedState.mAnchorPosition; } ensureLayoutState(); this.mLayoutState.mRecycle = false; resolveShouldLayoutReverse(); View focusedChild = getFocusedChild(); AnchorInfo anchorInfo = this.mAnchorInfo; if (!anchorInfo.mValid || this.mPendingScrollPosition != -1 || this.mPendingSavedState != null) { anchorInfo.reset(); AnchorInfo anchorInfo2 = this.mAnchorInfo; anchorInfo2.mLayoutFromEnd = this.mShouldReverseLayout ^ this.mStackFromEnd; updateAnchorInfoForLayout(recycler, state, anchorInfo2); this.mAnchorInfo.mValid = true; } else if (focusedChild != null && (this.mOrientationHelper.getDecoratedStart(focusedChild) >= this.mOrientationHelper.getEndAfterPadding() || this.mOrientationHelper.getDecoratedEnd(focusedChild) <= this.mOrientationHelper.getStartAfterPadding())) { this.mAnchorInfo.assignFromViewAndKeepVisibleRect(focusedChild, getPosition(focusedChild)); } LayoutState layoutState = this.mLayoutState; layoutState.mLayoutDirection = layoutState.mLastScrollDelta >= 0 ? 1 : -1; int[] iArr = this.mReusableIntPair; iArr[0] = 0; iArr[1] = 0; calculateExtraLayoutSpace(state, iArr); int iMax = Math.max(0, this.mReusableIntPair[0]) + this.mOrientationHelper.getStartAfterPadding(); int iMax2 = Math.max(0, this.mReusableIntPair[1]) + this.mOrientationHelper.getEndPadding(); if (state.isPreLayout() && (i6 = this.mPendingScrollPosition) != -1 && this.mPendingScrollPositionOffset != Integer.MIN_VALUE && (viewFindViewByPosition = findViewByPosition(i6)) != null) { if (this.mShouldReverseLayout) { endAfterPadding = this.mOrientationHelper.getEndAfterPadding() - this.mOrientationHelper.getDecoratedEnd(viewFindViewByPosition); decoratedStart = this.mPendingScrollPositionOffset; } else { decoratedStart = this.mOrientationHelper.getDecoratedStart(viewFindViewByPosition) - this.mOrientationHelper.getStartAfterPadding(); endAfterPadding = this.mPendingScrollPositionOffset; } int i8 = endAfterPadding - decoratedStart; if (i8 > 0) { iMax += i8; } else { iMax2 -= i8; } } AnchorInfo anchorInfo3 = this.mAnchorInfo; if (!anchorInfo3.mLayoutFromEnd ? !this.mShouldReverseLayout : this.mShouldReverseLayout) { i7 = 1; } onAnchorReady(recycler, state, anchorInfo3, i7); detachAndScrapAttachedViews(recycler); this.mLayoutState.mInfinite = resolveIsInfinite(); this.mLayoutState.mIsPreLayout = state.isPreLayout(); this.mLayoutState.mNoRecycleSpace = 0; AnchorInfo anchorInfo4 = this.mAnchorInfo; if (anchorInfo4.mLayoutFromEnd) { updateLayoutStateToFillStart(anchorInfo4); LayoutState layoutState2 = this.mLayoutState; layoutState2.mExtraFillSpace = iMax; fill(recycler, layoutState2, state, false); LayoutState layoutState3 = this.mLayoutState; i3 = layoutState3.mOffset; int i9 = layoutState3.mCurrentPosition; int i10 = layoutState3.mAvailable; if (i10 > 0) { iMax2 += i10; } updateLayoutStateToFillEnd(this.mAnchorInfo); LayoutState layoutState4 = this.mLayoutState; layoutState4.mExtraFillSpace = iMax2; layoutState4.mCurrentPosition += layoutState4.mItemDirection; fill(recycler, layoutState4, state, false); LayoutState layoutState5 = this.mLayoutState; i2 = layoutState5.mOffset; int i11 = layoutState5.mAvailable; if (i11 > 0) { updateLayoutStateToFillStart(i9, i3); LayoutState layoutState6 = this.mLayoutState; layoutState6.mExtraFillSpace = i11; fill(recycler, layoutState6, state, false); i3 = this.mLayoutState.mOffset; } } else { updateLayoutStateToFillEnd(anchorInfo4); LayoutState layoutState7 = this.mLayoutState; layoutState7.mExtraFillSpace = iMax2; fill(recycler, layoutState7, state, false); LayoutState layoutState8 = this.mLayoutState; i2 = layoutState8.mOffset; int i12 = layoutState8.mCurrentPosition; int i13 = layoutState8.mAvailable; if (i13 > 0) { iMax += i13; } updateLayoutStateToFillStart(this.mAnchorInfo); LayoutState layoutState9 = this.mLayoutState; layoutState9.mExtraFillSpace = iMax; layoutState9.mCurrentPosition += layoutState9.mItemDirection; fill(recycler, layoutState9, state, false); LayoutState layoutState10 = this.mLayoutState; i3 = layoutState10.mOffset; int i14 = layoutState10.mAvailable; if (i14 > 0) { updateLayoutStateToFillEnd(i12, i2); LayoutState layoutState11 = this.mLayoutState; layoutState11.mExtraFillSpace = i14; fill(recycler, layoutState11, state, false); i2 = this.mLayoutState.mOffset; } } if (getChildCount() > 0) { if (this.mShouldReverseLayout ^ this.mStackFromEnd) { int iFixLayoutEndGap2 = fixLayoutEndGap(i2, recycler, state, true); i4 = i3 + iFixLayoutEndGap2; i5 = i2 + iFixLayoutEndGap2; iFixLayoutEndGap = fixLayoutStartGap(i4, recycler, state, false); } else { int iFixLayoutStartGap = fixLayoutStartGap(i3, recycler, state, true); i4 = i3 + iFixLayoutStartGap; i5 = i2 + iFixLayoutStartGap; iFixLayoutEndGap = fixLayoutEndGap(i5, recycler, state, false); } i3 = i4 + iFixLayoutEndGap; i2 = i5 + iFixLayoutEndGap; } layoutForPredictiveAnimations(recycler, state, i3, i2); if (state.isPreLayout()) { this.mAnchorInfo.reset(); } else { this.mOrientationHelper.onLayoutComplete(); } this.mLastStackFromEnd = this.mStackFromEnd; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void onLayoutCompleted(RecyclerView.State state) { super.onLayoutCompleted(state); this.mPendingSavedState = null; this.mPendingScrollPosition = -1; this.mPendingScrollPositionOffset = Integer.MIN_VALUE; this.mAnchorInfo.reset(); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void onRestoreInstanceState(Parcelable parcelable) { if (parcelable instanceof SavedState) { SavedState savedState = (SavedState) parcelable; this.mPendingSavedState = savedState; if (this.mPendingScrollPosition != -1) { savedState.invalidateAnchor(); } requestLayout(); } } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public Parcelable onSaveInstanceState() { if (this.mPendingSavedState != null) { return new SavedState(this.mPendingSavedState); } SavedState savedState = new SavedState(); if (getChildCount() > 0) { ensureLayoutState(); boolean z2 = this.mLastStackFromEnd ^ this.mShouldReverseLayout; savedState.mAnchorLayoutFromEnd = z2; if (z2) { View childClosestToEnd = getChildClosestToEnd(); savedState.mAnchorOffset = this.mOrientationHelper.getEndAfterPadding() - this.mOrientationHelper.getDecoratedEnd(childClosestToEnd); savedState.mAnchorPosition = getPosition(childClosestToEnd); } else { View childClosestToStart = getChildClosestToStart(); savedState.mAnchorPosition = getPosition(childClosestToStart); savedState.mAnchorOffset = this.mOrientationHelper.getDecoratedStart(childClosestToStart) - this.mOrientationHelper.getStartAfterPadding(); } } else { savedState.invalidateAnchor(); } return savedState; } @Override // androidx.recyclerview.widget.ItemTouchHelper.ViewDropHandler public void prepareForDrop(@NonNull View view, @NonNull View view2, int i2, int i3) { assertNotInLayoutOrScroll("Cannot drop a view during a scroll or layout calculation"); ensureLayoutState(); resolveShouldLayoutReverse(); int position = getPosition(view); int position2 = getPosition(view2); byte b2 = position < position2 ? (byte) 1 : (byte) -1; if (this.mShouldReverseLayout) { if (b2 == 1) { scrollToPositionWithOffset(position2, this.mOrientationHelper.getEndAfterPadding() - (this.mOrientationHelper.getDecoratedStart(view2) + this.mOrientationHelper.getDecoratedMeasurement(view))); return; } else { scrollToPositionWithOffset(position2, this.mOrientationHelper.getEndAfterPadding() - this.mOrientationHelper.getDecoratedEnd(view2)); return; } } if (b2 == -1) { scrollToPositionWithOffset(position2, this.mOrientationHelper.getDecoratedStart(view2)); } else { scrollToPositionWithOffset(position2, this.mOrientationHelper.getDecoratedEnd(view2) - this.mOrientationHelper.getDecoratedMeasurement(view)); } } boolean resolveIsInfinite() { return this.mOrientationHelper.getMode() == 0 && this.mOrientationHelper.getEnd() == 0; } int scrollBy(int i2, RecyclerView.Recycler recycler, RecyclerView.State state) { if (getChildCount() == 0 || i2 == 0) { return 0; } ensureLayoutState(); this.mLayoutState.mRecycle = true; int i3 = i2 > 0 ? 1 : -1; int iAbs = Math.abs(i2); updateLayoutState(i3, iAbs, true, state); LayoutState layoutState = this.mLayoutState; int iFill = layoutState.mScrollingOffset + fill(recycler, layoutState, state, false); if (iFill < 0) { return 0; } if (iAbs > iFill) { i2 = i3 * iFill; } this.mOrientationHelper.offsetChildren(-i2); this.mLayoutState.mLastScrollDelta = i2; return i2; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int scrollHorizontallyBy(int i2, RecyclerView.Recycler recycler, RecyclerView.State state) { if (this.mOrientation == 1) { return 0; } return scrollBy(i2, recycler, state); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void scrollToPosition(int i2) { this.mPendingScrollPosition = i2; this.mPendingScrollPositionOffset = Integer.MIN_VALUE; SavedState savedState = this.mPendingSavedState; if (savedState != null) { savedState.invalidateAnchor(); } requestLayout(); } public void scrollToPositionWithOffset(int i2, int i3) { this.mPendingScrollPosition = i2; this.mPendingScrollPositionOffset = i3; SavedState savedState = this.mPendingSavedState; if (savedState != null) { savedState.invalidateAnchor(); } requestLayout(); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public int scrollVerticallyBy(int i2, RecyclerView.Recycler recycler, RecyclerView.State state) { if (this.mOrientation == 0) { return 0; } return scrollBy(i2, recycler, state); } public void setInitialPrefetchItemCount(int i2) { this.mInitialPrefetchItemCount = i2; } public void setOrientation(int i2) { if (i2 != 0 && i2 != 1) { throw new IllegalArgumentException("invalid orientation:" + i2); } assertNotInLayoutOrScroll(null); if (i2 != this.mOrientation || this.mOrientationHelper == null) { OrientationHelper orientationHelperCreateOrientationHelper = OrientationHelper.createOrientationHelper(this, i2); this.mOrientationHelper = orientationHelperCreateOrientationHelper; this.mAnchorInfo.mOrientationHelper = orientationHelperCreateOrientationHelper; this.mOrientation = i2; requestLayout(); } } public void setRecycleChildrenOnDetach(boolean z2) { this.mRecycleChildrenOnDetach = z2; } public void setReverseLayout(boolean z2) { assertNotInLayoutOrScroll(null); if (z2 == this.mReverseLayout) { return; } this.mReverseLayout = z2; requestLayout(); } public void setSmoothScrollbarEnabled(boolean z2) { this.mSmoothScrollbarEnabled = z2; } public void setStackFromEnd(boolean z2) { assertNotInLayoutOrScroll(null); if (this.mStackFromEnd == z2) { return; } this.mStackFromEnd = z2; requestLayout(); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager boolean shouldMeasureTwice() { return (getHeightMode() == 1073741824 || getWidthMode() == 1073741824 || !hasFlexibleChildInBothOrientations()) ? false : true; } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int i2) { LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()); linearSmoothScroller.setTargetPosition(i2); startSmoothScroll(linearSmoothScroller); } @Override // androidx.recyclerview.widget.RecyclerView.LayoutManager public boolean supportsPredictiveItemAnimations() { return this.mPendingSavedState == null && this.mLastStackFromEnd == this.mStackFromEnd; } void validateChildOrder() { Log.d(TAG, "validating child count " + getChildCount()); if (getChildCount() < 1) { return; } int position = getPosition(getChildAt(0)); int decoratedStart = this.mOrientationHelper.getDecoratedStart(getChildAt(0)); if (this.mShouldReverseLayout) { for (int i2 = 1; i2 < getChildCount(); i2++) { View childAt = getChildAt(i2); int position2 = getPosition(childAt); int decoratedStart2 = this.mOrientationHelper.getDecoratedStart(childAt); if (position2 < position) { logChildren(); StringBuilder sb = new StringBuilder(); sb.append("detected invalid position. loc invalid? "); sb.append(decoratedStart2 < decoratedStart); throw new RuntimeException(sb.toString()); } if (decoratedStart2 > decoratedStart) { logChildren(); throw new RuntimeException("detected invalid location"); } } return; } for (int i3 = 1; i3 < getChildCount(); i3++) { View childAt2 = getChildAt(i3); int position3 = getPosition(childAt2); int decoratedStart3 = this.mOrientationHelper.getDecoratedStart(childAt2); if (position3 < position) { logChildren(); StringBuilder sb2 = new StringBuilder(); sb2.append("detected invalid position. loc invalid? "); sb2.append(decoratedStart3 < decoratedStart); throw new RuntimeException(sb2.toString()); } if (decoratedStart3 < decoratedStart) { logChildren(); throw new RuntimeException("detected invalid location"); } } } public LinearLayoutManager(Context context, int i2, boolean z2) { this.mOrientation = 1; this.mReverseLayout = false; this.mShouldReverseLayout = false; this.mStackFromEnd = false; this.mSmoothScrollbarEnabled = true; this.mPendingScrollPosition = -1; this.mPendingScrollPositionOffset = Integer.MIN_VALUE; this.mPendingSavedState = null; this.mAnchorInfo = new AnchorInfo(); this.mLayoutChunkResult = new LayoutChunkResult(); this.mInitialPrefetchItemCount = 2; this.mReusableIntPair = new int[2]; setOrientation(i2); setReverseLayout(z2); } private void updateLayoutStateToFillEnd(int i2, int i3) { this.mLayoutState.mAvailable = this.mOrientationHelper.getEndAfterPadding() - i3; LayoutState layoutState = this.mLayoutState; layoutState.mItemDirection = this.mShouldReverseLayout ? -1 : 1; layoutState.mCurrentPosition = i2; layoutState.mLayoutDirection = 1; layoutState.mOffset = i3; layoutState.mScrollingOffset = Integer.MIN_VALUE; } private void updateLayoutStateToFillStart(int i2, int i3) { this.mLayoutState.mAvailable = i3 - this.mOrientationHelper.getStartAfterPadding(); LayoutState layoutState = this.mLayoutState; layoutState.mCurrentPosition = i2; layoutState.mItemDirection = this.mShouldReverseLayout ? 1 : -1; layoutState.mLayoutDirection = -1; layoutState.mOffset = i3; layoutState.mScrollingOffset = Integer.MIN_VALUE; } public LinearLayoutManager(Context context, AttributeSet attributeSet, int i2, int i3) { this.mOrientation = 1; this.mReverseLayout = false; this.mShouldReverseLayout = false; this.mStackFromEnd = false; this.mSmoothScrollbarEnabled = true; this.mPendingScrollPosition = -1; this.mPendingScrollPositionOffset = Integer.MIN_VALUE; this.mPendingSavedState = null; this.mAnchorInfo = new AnchorInfo(); this.mLayoutChunkResult = new LayoutChunkResult(); this.mInitialPrefetchItemCount = 2; this.mReusableIntPair = new int[2]; RecyclerView.LayoutManager.Properties properties = RecyclerView.LayoutManager.getProperties(context, attributeSet, i2, i3); setOrientation(properties.orientation); setReverseLayout(properties.reverseLayout); setStackFromEnd(properties.stackFromEnd); } }