966 lines
43 KiB
Java
966 lines
43 KiB
Java
package com.google.android.material.carousel;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.graphics.PointF;
|
|
import android.graphics.Rect;
|
|
import android.graphics.RectF;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.view.View;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import androidx.core.graphics.ColorUtils;
|
|
import androidx.core.math.MathUtils;
|
|
import androidx.core.util.Preconditions;
|
|
import androidx.recyclerview.widget.LinearSmoothScroller;
|
|
import androidx.recyclerview.widget.RecyclerView;
|
|
import com.google.android.material.R;
|
|
import com.google.android.material.animation.AnimationUtils;
|
|
import com.google.android.material.carousel.KeylineState;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class CarouselLayoutManager extends RecyclerView.LayoutManager implements Carousel, RecyclerView.SmoothScroller.ScrollVectorProvider {
|
|
public static final int ALIGNMENT_CENTER = 1;
|
|
public static final int ALIGNMENT_START = 0;
|
|
public static final int HORIZONTAL = 0;
|
|
private static final String TAG = "CarouselLayoutManager";
|
|
public static final int VERTICAL = 1;
|
|
private int carouselAlignment;
|
|
private CarouselStrategy carouselStrategy;
|
|
private int currentEstimatedPosition;
|
|
private int currentFillStartPosition;
|
|
private KeylineState currentKeylineState;
|
|
private final DebugItemDecoration debugItemDecoration;
|
|
private boolean isDebuggingEnabled;
|
|
private KeylineStateList keylineStateList;
|
|
private Map<Integer, KeylineState> keylineStatePositionMap;
|
|
private int lastItemCount;
|
|
int maxScroll;
|
|
int minScroll;
|
|
private CarouselOrientationHelper orientationHelper;
|
|
private final View.OnLayoutChangeListener recyclerViewSizeChangeListener;
|
|
int scrollOffset;
|
|
|
|
private static int calculateShouldScrollBy(int i, int i2, int i3, int i4) {
|
|
int i5 = i2 + i;
|
|
return i5 < i3 ? i3 - i2 : i5 > i4 ? i4 - i2 : i;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int computeHorizontalScrollOffset(RecyclerView.State state) {
|
|
return this.scrollOffset;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int computeHorizontalScrollRange(RecyclerView.State state) {
|
|
return this.maxScroll - this.minScroll;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int computeVerticalScrollOffset(RecyclerView.State state) {
|
|
return this.scrollOffset;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int computeVerticalScrollRange(RecyclerView.State state) {
|
|
return this.maxScroll - this.minScroll;
|
|
}
|
|
|
|
@Override // com.google.android.material.carousel.Carousel
|
|
public int getCarouselAlignment() {
|
|
return this.carouselAlignment;
|
|
}
|
|
|
|
/* renamed from: lambda$new$0$com-google-android-material-carousel-CarouselLayoutManager, reason: not valid java name */
|
|
/* synthetic */ void m195x2ff337cb(View view, int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
|
|
if (i == i5 && i2 == i6 && i3 == i7 && i4 == i8) {
|
|
return;
|
|
}
|
|
view.post(new Runnable() { // from class: com.google.android.material.carousel.CarouselLayoutManager$$ExternalSyntheticLambda0
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
CarouselLayoutManager.this.refreshKeylineState();
|
|
}
|
|
});
|
|
}
|
|
|
|
private static final class ChildCalculations {
|
|
final float center;
|
|
final View child;
|
|
final float offsetCenter;
|
|
final KeylineRange range;
|
|
|
|
ChildCalculations(View view, float f, float f2, KeylineRange keylineRange) {
|
|
this.child = view;
|
|
this.center = f;
|
|
this.offsetCenter = f2;
|
|
this.range = keylineRange;
|
|
}
|
|
}
|
|
|
|
public CarouselLayoutManager() {
|
|
this(new MultiBrowseCarouselStrategy());
|
|
}
|
|
|
|
public CarouselLayoutManager(CarouselStrategy carouselStrategy) {
|
|
this(carouselStrategy, 0);
|
|
}
|
|
|
|
public CarouselLayoutManager(CarouselStrategy carouselStrategy, int i) {
|
|
this.isDebuggingEnabled = false;
|
|
this.debugItemDecoration = new DebugItemDecoration();
|
|
this.currentFillStartPosition = 0;
|
|
this.recyclerViewSizeChangeListener = new View.OnLayoutChangeListener() { // from class: com.google.android.material.carousel.CarouselLayoutManager$$ExternalSyntheticLambda1
|
|
@Override // android.view.View.OnLayoutChangeListener
|
|
public final void onLayoutChange(View view, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9) {
|
|
CarouselLayoutManager.this.m195x2ff337cb(view, i2, i3, i4, i5, i6, i7, i8, i9);
|
|
}
|
|
};
|
|
this.currentEstimatedPosition = -1;
|
|
this.carouselAlignment = 0;
|
|
setCarouselStrategy(carouselStrategy);
|
|
setOrientation(i);
|
|
}
|
|
|
|
public CarouselLayoutManager(Context context, AttributeSet attributeSet, int i, int i2) {
|
|
this.isDebuggingEnabled = false;
|
|
this.debugItemDecoration = new DebugItemDecoration();
|
|
this.currentFillStartPosition = 0;
|
|
this.recyclerViewSizeChangeListener = new View.OnLayoutChangeListener() { // from class: com.google.android.material.carousel.CarouselLayoutManager$$ExternalSyntheticLambda1
|
|
@Override // android.view.View.OnLayoutChangeListener
|
|
public final void onLayoutChange(View view, int i22, int i3, int i4, int i5, int i6, int i7, int i8, int i9) {
|
|
CarouselLayoutManager.this.m195x2ff337cb(view, i22, i3, i4, i5, i6, i7, i8, i9);
|
|
}
|
|
};
|
|
this.currentEstimatedPosition = -1;
|
|
this.carouselAlignment = 0;
|
|
setCarouselStrategy(new MultiBrowseCarouselStrategy());
|
|
setCarouselAttributes(context, attributeSet);
|
|
}
|
|
|
|
private void setCarouselAttributes(Context context, AttributeSet attributeSet) {
|
|
if (attributeSet != null) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Carousel);
|
|
setCarouselAlignment(obtainStyledAttributes.getInt(R.styleable.Carousel_carousel_alignment, 0));
|
|
setOrientation(obtainStyledAttributes.getInt(R.styleable.RecyclerView_android_orientation, 0));
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
|
|
public void setCarouselAlignment(int i) {
|
|
this.carouselAlignment = i;
|
|
refreshKeylineState();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public RecyclerView.LayoutParams generateDefaultLayoutParams() {
|
|
return new RecyclerView.LayoutParams(-2, -2);
|
|
}
|
|
|
|
public void setCarouselStrategy(CarouselStrategy carouselStrategy) {
|
|
this.carouselStrategy = carouselStrategy;
|
|
refreshKeylineState();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onAttachedToWindow(RecyclerView recyclerView) {
|
|
super.onAttachedToWindow(recyclerView);
|
|
refreshKeylineState();
|
|
recyclerView.addOnLayoutChangeListener(this.recyclerViewSizeChangeListener);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onDetachedFromWindow(RecyclerView recyclerView, RecyclerView.Recycler recycler) {
|
|
super.onDetachedFromWindow(recyclerView, recycler);
|
|
recyclerView.removeOnLayoutChangeListener(this.recyclerViewSizeChangeListener);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
|
|
if (state.getItemCount() <= 0 || getContainerSize() <= 0.0f) {
|
|
removeAndRecycleAllViews(recycler);
|
|
this.currentFillStartPosition = 0;
|
|
return;
|
|
}
|
|
boolean isLayoutRtl = isLayoutRtl();
|
|
boolean z = this.keylineStateList == null;
|
|
if (z) {
|
|
recalculateKeylineStateList(recycler);
|
|
}
|
|
int calculateStartScroll = calculateStartScroll(this.keylineStateList);
|
|
int calculateEndScroll = calculateEndScroll(state, this.keylineStateList);
|
|
this.minScroll = isLayoutRtl ? calculateEndScroll : calculateStartScroll;
|
|
if (isLayoutRtl) {
|
|
calculateEndScroll = calculateStartScroll;
|
|
}
|
|
this.maxScroll = calculateEndScroll;
|
|
if (z) {
|
|
this.scrollOffset = calculateStartScroll;
|
|
this.keylineStatePositionMap = this.keylineStateList.getKeylineStateForPositionMap(getItemCount(), this.minScroll, this.maxScroll, isLayoutRtl());
|
|
int i = this.currentEstimatedPosition;
|
|
if (i != -1) {
|
|
this.scrollOffset = getScrollOffsetForPosition(i, getKeylineStateForPosition(i));
|
|
}
|
|
}
|
|
int i2 = this.scrollOffset;
|
|
this.scrollOffset = i2 + calculateShouldScrollBy(0, i2, this.minScroll, this.maxScroll);
|
|
this.currentFillStartPosition = MathUtils.clamp(this.currentFillStartPosition, 0, state.getItemCount());
|
|
updateCurrentKeylineStateForScrollOffset(this.keylineStateList);
|
|
detachAndScrapAttachedViews(recycler);
|
|
fill(recycler, state);
|
|
this.lastItemCount = getItemCount();
|
|
}
|
|
|
|
private void recalculateKeylineStateList(RecyclerView.Recycler recycler) {
|
|
View viewForPosition = recycler.getViewForPosition(0);
|
|
measureChildWithMargins(viewForPosition, 0, 0);
|
|
KeylineState onFirstChildMeasuredWithMargins = this.carouselStrategy.onFirstChildMeasuredWithMargins(this, viewForPosition);
|
|
if (isLayoutRtl()) {
|
|
onFirstChildMeasuredWithMargins = KeylineState.reverse(onFirstChildMeasuredWithMargins, getContainerSize());
|
|
}
|
|
this.keylineStateList = KeylineStateList.from(this, onFirstChildMeasuredWithMargins);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void refreshKeylineState() {
|
|
this.keylineStateList = null;
|
|
requestLayout();
|
|
}
|
|
|
|
private void fill(RecyclerView.Recycler recycler, RecyclerView.State state) {
|
|
removeAndRecycleOutOfBoundsViews(recycler);
|
|
if (getChildCount() == 0) {
|
|
addViewsStart(recycler, this.currentFillStartPosition - 1);
|
|
addViewsEnd(recycler, state, this.currentFillStartPosition);
|
|
} else {
|
|
int position = getPosition(getChildAt(0));
|
|
int position2 = getPosition(getChildAt(getChildCount() - 1));
|
|
addViewsStart(recycler, position - 1);
|
|
addViewsEnd(recycler, state, position2 + 1);
|
|
}
|
|
validateChildOrderIfDebugging();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onLayoutCompleted(RecyclerView.State state) {
|
|
super.onLayoutCompleted(state);
|
|
if (getChildCount() == 0) {
|
|
this.currentFillStartPosition = 0;
|
|
} else {
|
|
this.currentFillStartPosition = getPosition(getChildAt(0));
|
|
}
|
|
validateChildOrderIfDebugging();
|
|
}
|
|
|
|
private void addViewsStart(RecyclerView.Recycler recycler, int i) {
|
|
float calculateChildStartForFill = calculateChildStartForFill(i);
|
|
while (i >= 0) {
|
|
ChildCalculations makeChildCalculations = makeChildCalculations(recycler, calculateChildStartForFill, i);
|
|
if (isLocOffsetOutOfFillBoundsStart(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
|
|
return;
|
|
}
|
|
calculateChildStartForFill = addStart(calculateChildStartForFill, this.currentKeylineState.getItemSize());
|
|
if (!isLocOffsetOutOfFillBoundsEnd(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
|
|
addAndLayoutView(makeChildCalculations.child, 0, makeChildCalculations);
|
|
}
|
|
i--;
|
|
}
|
|
}
|
|
|
|
private void addViewAtPosition(RecyclerView.Recycler recycler, int i, int i2) {
|
|
if (i < 0 || i >= getItemCount()) {
|
|
return;
|
|
}
|
|
ChildCalculations makeChildCalculations = makeChildCalculations(recycler, calculateChildStartForFill(i), i);
|
|
addAndLayoutView(makeChildCalculations.child, i2, makeChildCalculations);
|
|
}
|
|
|
|
private void addViewsEnd(RecyclerView.Recycler recycler, RecyclerView.State state, int i) {
|
|
float calculateChildStartForFill = calculateChildStartForFill(i);
|
|
while (i < state.getItemCount()) {
|
|
ChildCalculations makeChildCalculations = makeChildCalculations(recycler, calculateChildStartForFill, i);
|
|
if (isLocOffsetOutOfFillBoundsEnd(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
|
|
return;
|
|
}
|
|
calculateChildStartForFill = addEnd(calculateChildStartForFill, this.currentKeylineState.getItemSize());
|
|
if (!isLocOffsetOutOfFillBoundsStart(makeChildCalculations.offsetCenter, makeChildCalculations.range)) {
|
|
addAndLayoutView(makeChildCalculations.child, -1, makeChildCalculations);
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
private void logChildrenIfDebugging() {
|
|
if (this.isDebuggingEnabled && Log.isLoggable(TAG, 3)) {
|
|
Log.d(TAG, "internal representation of views on the screen");
|
|
for (int i = 0; i < getChildCount(); i++) {
|
|
View childAt = getChildAt(i);
|
|
Log.d(TAG, "item position " + getPosition(childAt) + ", center:" + getDecoratedCenterWithMargins(childAt) + ", child index:" + i);
|
|
}
|
|
Log.d(TAG, "==============");
|
|
}
|
|
}
|
|
|
|
private void validateChildOrderIfDebugging() {
|
|
if (!this.isDebuggingEnabled || getChildCount() < 1) {
|
|
return;
|
|
}
|
|
int i = 0;
|
|
while (i < getChildCount() - 1) {
|
|
int position = getPosition(getChildAt(i));
|
|
int i2 = i + 1;
|
|
int position2 = getPosition(getChildAt(i2));
|
|
if (position > position2) {
|
|
logChildrenIfDebugging();
|
|
throw new IllegalStateException("Detected invalid child order. Child at index [" + i + "] had adapter position [" + position + "] and child at index [" + i2 + "] had adapter position [" + position2 + "].");
|
|
}
|
|
i = i2;
|
|
}
|
|
}
|
|
|
|
private ChildCalculations makeChildCalculations(RecyclerView.Recycler recycler, float f, int i) {
|
|
View viewForPosition = recycler.getViewForPosition(i);
|
|
measureChildWithMargins(viewForPosition, 0, 0);
|
|
float addEnd = addEnd(f, this.currentKeylineState.getItemSize() / 2.0f);
|
|
KeylineRange surroundingKeylineRange = getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), addEnd, false);
|
|
return new ChildCalculations(viewForPosition, addEnd, calculateChildOffsetCenterForLocation(viewForPosition, addEnd, surroundingKeylineRange), surroundingKeylineRange);
|
|
}
|
|
|
|
private void addAndLayoutView(View view, int i, ChildCalculations childCalculations) {
|
|
float itemSize = this.currentKeylineState.getItemSize() / 2.0f;
|
|
addView(view, i);
|
|
this.orientationHelper.layoutDecoratedWithMargins(view, (int) (childCalculations.offsetCenter - itemSize), (int) (childCalculations.offsetCenter + itemSize));
|
|
updateChildMaskForLocation(view, childCalculations.center, childCalculations.range);
|
|
}
|
|
|
|
private boolean isLocOffsetOutOfFillBoundsStart(float f, KeylineRange keylineRange) {
|
|
float addEnd = addEnd(f, getMaskedItemSizeForLocOffset(f, keylineRange) / 2.0f);
|
|
if (isLayoutRtl()) {
|
|
if (addEnd > getContainerSize()) {
|
|
return true;
|
|
}
|
|
} else if (addEnd < 0.0f) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // com.google.android.material.carousel.Carousel
|
|
public boolean isHorizontal() {
|
|
return this.orientationHelper.orientation == 0;
|
|
}
|
|
|
|
private boolean isLocOffsetOutOfFillBoundsEnd(float f, KeylineRange keylineRange) {
|
|
float addStart = addStart(f, getMaskedItemSizeForLocOffset(f, keylineRange) / 2.0f);
|
|
if (isLayoutRtl()) {
|
|
if (addStart < 0.0f) {
|
|
return true;
|
|
}
|
|
} else if (addStart > getContainerSize()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void getDecoratedBoundsWithMargins(View view, Rect rect) {
|
|
super.getDecoratedBoundsWithMargins(view, rect);
|
|
float centerY = rect.centerY();
|
|
if (isHorizontal()) {
|
|
centerY = rect.centerX();
|
|
}
|
|
float maskedItemSizeForLocOffset = getMaskedItemSizeForLocOffset(centerY, getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), centerY, true));
|
|
float width = isHorizontal() ? (rect.width() - maskedItemSizeForLocOffset) / 2.0f : 0.0f;
|
|
float height = isHorizontal() ? 0.0f : (rect.height() - maskedItemSizeForLocOffset) / 2.0f;
|
|
rect.set((int) (rect.left + width), (int) (rect.top + height), (int) (rect.right - width), (int) (rect.bottom - height));
|
|
}
|
|
|
|
private float getDecoratedCenterWithMargins(View view) {
|
|
int centerY;
|
|
Rect rect = new Rect();
|
|
super.getDecoratedBoundsWithMargins(view, rect);
|
|
if (isHorizontal()) {
|
|
centerY = rect.centerX();
|
|
} else {
|
|
centerY = rect.centerY();
|
|
}
|
|
return centerY;
|
|
}
|
|
|
|
private void removeAndRecycleOutOfBoundsViews(RecyclerView.Recycler recycler) {
|
|
while (getChildCount() > 0) {
|
|
View childAt = getChildAt(0);
|
|
float decoratedCenterWithMargins = getDecoratedCenterWithMargins(childAt);
|
|
if (!isLocOffsetOutOfFillBoundsStart(decoratedCenterWithMargins, getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), decoratedCenterWithMargins, true))) {
|
|
break;
|
|
} else {
|
|
removeAndRecycleView(childAt, recycler);
|
|
}
|
|
}
|
|
while (getChildCount() - 1 >= 0) {
|
|
View childAt2 = getChildAt(getChildCount() - 1);
|
|
float decoratedCenterWithMargins2 = getDecoratedCenterWithMargins(childAt2);
|
|
if (!isLocOffsetOutOfFillBoundsEnd(decoratedCenterWithMargins2, getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), decoratedCenterWithMargins2, true))) {
|
|
return;
|
|
} else {
|
|
removeAndRecycleView(childAt2, recycler);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static KeylineRange getSurroundingKeylineRange(List<KeylineState.Keyline> list, float f, boolean z) {
|
|
float f2 = Float.MAX_VALUE;
|
|
float f3 = Float.MAX_VALUE;
|
|
float f4 = Float.MAX_VALUE;
|
|
float f5 = -3.4028235E38f;
|
|
int i = -1;
|
|
int i2 = -1;
|
|
int i3 = -1;
|
|
int i4 = -1;
|
|
for (int i5 = 0; i5 < list.size(); i5++) {
|
|
KeylineState.Keyline keyline = list.get(i5);
|
|
float f6 = z ? keyline.locOffset : keyline.loc;
|
|
float abs = Math.abs(f6 - f);
|
|
if (f6 <= f && abs <= f2) {
|
|
i = i5;
|
|
f2 = abs;
|
|
}
|
|
if (f6 > f && abs <= f3) {
|
|
i3 = i5;
|
|
f3 = abs;
|
|
}
|
|
if (f6 <= f4) {
|
|
i2 = i5;
|
|
f4 = f6;
|
|
}
|
|
if (f6 > f5) {
|
|
i4 = i5;
|
|
f5 = f6;
|
|
}
|
|
}
|
|
if (i == -1) {
|
|
i = i2;
|
|
}
|
|
if (i3 == -1) {
|
|
i3 = i4;
|
|
}
|
|
return new KeylineRange(list.get(i), list.get(i3));
|
|
}
|
|
|
|
private void updateCurrentKeylineStateForScrollOffset(KeylineStateList keylineStateList) {
|
|
int i = this.maxScroll;
|
|
int i2 = this.minScroll;
|
|
if (i <= i2) {
|
|
this.currentKeylineState = isLayoutRtl() ? keylineStateList.getEndState() : keylineStateList.getStartState();
|
|
} else {
|
|
this.currentKeylineState = keylineStateList.getShiftedState(this.scrollOffset, i2, i);
|
|
}
|
|
this.debugItemDecoration.setKeylines(this.currentKeylineState.getKeylines());
|
|
}
|
|
|
|
private int calculateStartScroll(KeylineStateList keylineStateList) {
|
|
boolean isLayoutRtl = isLayoutRtl();
|
|
KeylineState endState = isLayoutRtl ? keylineStateList.getEndState() : keylineStateList.getStartState();
|
|
return (int) (((getPaddingStart() * (isLayoutRtl ? 1 : -1)) + getParentStart()) - addStart((isLayoutRtl ? endState.getLastFocalKeyline() : endState.getFirstFocalKeyline()).loc, endState.getItemSize() / 2.0f));
|
|
}
|
|
|
|
private int calculateEndScroll(RecyclerView.State state, KeylineStateList keylineStateList) {
|
|
boolean isLayoutRtl = isLayoutRtl();
|
|
KeylineState startState = isLayoutRtl ? keylineStateList.getStartState() : keylineStateList.getEndState();
|
|
KeylineState.Keyline firstFocalKeyline = isLayoutRtl ? startState.getFirstFocalKeyline() : startState.getLastFocalKeyline();
|
|
int itemCount = (int) ((((((state.getItemCount() - 1) * startState.getItemSize()) + getPaddingEnd()) * (isLayoutRtl ? -1.0f : 1.0f)) - (firstFocalKeyline.loc - getParentStart())) + (getParentEnd() - firstFocalKeyline.loc));
|
|
return isLayoutRtl ? Math.min(0, itemCount) : Math.max(0, itemCount);
|
|
}
|
|
|
|
private float calculateChildStartForFill(int i) {
|
|
return addEnd(getParentStart() - this.scrollOffset, this.currentKeylineState.getItemSize() * i);
|
|
}
|
|
|
|
private float calculateChildOffsetCenterForLocation(View view, float f, KeylineRange keylineRange) {
|
|
float lerp = AnimationUtils.lerp(keylineRange.leftOrTop.locOffset, keylineRange.rightOrBottom.locOffset, keylineRange.leftOrTop.loc, keylineRange.rightOrBottom.loc, f);
|
|
if (keylineRange.rightOrBottom != this.currentKeylineState.getFirstKeyline() && keylineRange.leftOrTop != this.currentKeylineState.getLastKeyline()) {
|
|
return lerp;
|
|
}
|
|
return lerp + ((f - keylineRange.rightOrBottom.loc) * ((1.0f - keylineRange.rightOrBottom.mask) + (this.orientationHelper.getMaskMargins((RecyclerView.LayoutParams) view.getLayoutParams()) / this.currentKeylineState.getItemSize())));
|
|
}
|
|
|
|
private float getMaskedItemSizeForLocOffset(float f, KeylineRange keylineRange) {
|
|
return AnimationUtils.lerp(keylineRange.leftOrTop.maskedItemSize, keylineRange.rightOrBottom.maskedItemSize, keylineRange.leftOrTop.locOffset, keylineRange.rightOrBottom.locOffset, f);
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
private void updateChildMaskForLocation(View view, float f, KeylineRange keylineRange) {
|
|
if (view instanceof Maskable) {
|
|
float lerp = AnimationUtils.lerp(keylineRange.leftOrTop.mask, keylineRange.rightOrBottom.mask, keylineRange.leftOrTop.loc, keylineRange.rightOrBottom.loc, f);
|
|
float height = view.getHeight();
|
|
float width = view.getWidth();
|
|
RectF maskRect = this.orientationHelper.getMaskRect(height, width, AnimationUtils.lerp(0.0f, height / 2.0f, 0.0f, 1.0f, lerp), AnimationUtils.lerp(0.0f, width / 2.0f, 0.0f, 1.0f, lerp));
|
|
float calculateChildOffsetCenterForLocation = calculateChildOffsetCenterForLocation(view, f, keylineRange);
|
|
RectF rectF = new RectF(calculateChildOffsetCenterForLocation - (maskRect.width() / 2.0f), calculateChildOffsetCenterForLocation - (maskRect.height() / 2.0f), calculateChildOffsetCenterForLocation + (maskRect.width() / 2.0f), (maskRect.height() / 2.0f) + calculateChildOffsetCenterForLocation);
|
|
RectF rectF2 = new RectF(getParentLeft(), getParentTop(), getParentRight(), getParentBottom());
|
|
if (this.carouselStrategy.isContained()) {
|
|
this.orientationHelper.containMaskWithinBounds(maskRect, rectF, rectF2);
|
|
}
|
|
this.orientationHelper.moveMaskOnEdgeOutsideBounds(maskRect, rectF, rectF2);
|
|
((Maskable) view).setMaskRectF(maskRect);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void measureChildWithMargins(View view, int i, int i2) {
|
|
float f;
|
|
float f2;
|
|
if (!(view instanceof Maskable)) {
|
|
throw new IllegalStateException("All children of a RecyclerView using CarouselLayoutManager must use MaskableFrameLayout as their root ViewGroup.");
|
|
}
|
|
RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) view.getLayoutParams();
|
|
Rect rect = new Rect();
|
|
calculateItemDecorationsForChild(view, rect);
|
|
int i3 = i + rect.left + rect.right;
|
|
int i4 = i2 + rect.top + rect.bottom;
|
|
if (this.keylineStateList != null && this.orientationHelper.orientation == 0) {
|
|
f = this.keylineStateList.getDefaultState().getItemSize();
|
|
} else {
|
|
f = layoutParams.width;
|
|
}
|
|
if (this.keylineStateList != null && this.orientationHelper.orientation == 1) {
|
|
f2 = this.keylineStateList.getDefaultState().getItemSize();
|
|
} else {
|
|
f2 = layoutParams.height;
|
|
}
|
|
view.measure(getChildMeasureSpec(getWidth(), getWidthMode(), getPaddingLeft() + getPaddingRight() + layoutParams.leftMargin + layoutParams.rightMargin + i3, (int) f, canScrollHorizontally()), getChildMeasureSpec(getHeight(), getHeightMode(), getPaddingTop() + getPaddingBottom() + layoutParams.topMargin + layoutParams.bottomMargin + i4, (int) f2, canScrollVertically()));
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public int getParentLeft() {
|
|
return this.orientationHelper.getParentLeft();
|
|
}
|
|
|
|
private int getParentStart() {
|
|
return this.orientationHelper.getParentStart();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public int getParentRight() {
|
|
return this.orientationHelper.getParentRight();
|
|
}
|
|
|
|
private int getParentEnd() {
|
|
return this.orientationHelper.getParentEnd();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public int getParentTop() {
|
|
return this.orientationHelper.getParentTop();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public int getParentBottom() {
|
|
return this.orientationHelper.getParentBottom();
|
|
}
|
|
|
|
@Override // com.google.android.material.carousel.Carousel
|
|
public int getContainerWidth() {
|
|
return getWidth();
|
|
}
|
|
|
|
@Override // com.google.android.material.carousel.Carousel
|
|
public int getContainerHeight() {
|
|
return getHeight();
|
|
}
|
|
|
|
private int getContainerSize() {
|
|
if (isHorizontal()) {
|
|
return getContainerWidth();
|
|
}
|
|
return getContainerHeight();
|
|
}
|
|
|
|
boolean isLayoutRtl() {
|
|
return isHorizontal() && getLayoutDirection() == 1;
|
|
}
|
|
|
|
private float addStart(float f, float f2) {
|
|
return isLayoutRtl() ? f + f2 : f - f2;
|
|
}
|
|
|
|
private float addEnd(float f, float f2) {
|
|
return isLayoutRtl() ? f - f2 : f + f2;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onInitializeAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
|
|
super.onInitializeAccessibilityEvent(accessibilityEvent);
|
|
if (getChildCount() > 0) {
|
|
accessibilityEvent.setFromIndex(getPosition(getChildAt(0)));
|
|
accessibilityEvent.setToIndex(getPosition(getChildAt(getChildCount() - 1)));
|
|
}
|
|
}
|
|
|
|
private int getScrollOffsetForPosition(int i, KeylineState keylineState) {
|
|
if (isLayoutRtl()) {
|
|
return (int) (((getContainerSize() - keylineState.getLastFocalKeyline().loc) - (i * keylineState.getItemSize())) - (keylineState.getItemSize() / 2.0f));
|
|
}
|
|
return (int) (((i * keylineState.getItemSize()) - keylineState.getFirstFocalKeyline().loc) + (keylineState.getItemSize() / 2.0f));
|
|
}
|
|
|
|
private int getSmallestScrollOffsetToFocalKeyline(int i, KeylineState keylineState) {
|
|
int i2;
|
|
int i3 = Integer.MAX_VALUE;
|
|
for (KeylineState.Keyline keyline : keylineState.getFocalKeylines()) {
|
|
float itemSize = (i * keylineState.getItemSize()) + (keylineState.getItemSize() / 2.0f);
|
|
if (isLayoutRtl()) {
|
|
i2 = (int) ((getContainerSize() - keyline.loc) - itemSize);
|
|
} else {
|
|
i2 = (int) (itemSize - keyline.loc);
|
|
}
|
|
int i4 = i2 - this.scrollOffset;
|
|
if (Math.abs(i3) > Math.abs(i4)) {
|
|
i3 = i4;
|
|
}
|
|
}
|
|
return i3;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.SmoothScroller.ScrollVectorProvider
|
|
public PointF computeScrollVectorForPosition(int i) {
|
|
if (this.keylineStateList == null) {
|
|
return null;
|
|
}
|
|
int offsetToScrollToPosition = getOffsetToScrollToPosition(i, getKeylineStateForPosition(i));
|
|
if (isHorizontal()) {
|
|
return new PointF(offsetToScrollToPosition, 0.0f);
|
|
}
|
|
return new PointF(0.0f, offsetToScrollToPosition);
|
|
}
|
|
|
|
int getOffsetToScrollToPosition(int i, KeylineState keylineState) {
|
|
return getScrollOffsetForPosition(i, keylineState) - this.scrollOffset;
|
|
}
|
|
|
|
int getOffsetToScrollToPositionForSnap(int i, boolean z) {
|
|
int offsetToScrollToPosition = getOffsetToScrollToPosition(i, this.keylineStateList.getShiftedState(this.scrollOffset, this.minScroll, this.maxScroll, true));
|
|
int offsetToScrollToPosition2 = this.keylineStatePositionMap != null ? getOffsetToScrollToPosition(i, getKeylineStateForPosition(i)) : offsetToScrollToPosition;
|
|
return (!z || Math.abs(offsetToScrollToPosition2) >= Math.abs(offsetToScrollToPosition)) ? offsetToScrollToPosition : offsetToScrollToPosition2;
|
|
}
|
|
|
|
private KeylineState getKeylineStateForPosition(int i) {
|
|
KeylineState keylineState;
|
|
Map<Integer, KeylineState> map = this.keylineStatePositionMap;
|
|
return (map == null || (keylineState = map.get(Integer.valueOf(MathUtils.clamp(i, 0, Math.max(0, getItemCount() + (-1)))))) == null) ? this.keylineStateList.getDefaultState() : keylineState;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void scrollToPosition(int i) {
|
|
this.currentEstimatedPosition = i;
|
|
if (this.keylineStateList == null) {
|
|
return;
|
|
}
|
|
this.scrollOffset = getScrollOffsetForPosition(i, getKeylineStateForPosition(i));
|
|
this.currentFillStartPosition = MathUtils.clamp(i, 0, Math.max(0, getItemCount() - 1));
|
|
updateCurrentKeylineStateForScrollOffset(this.keylineStateList);
|
|
requestLayout();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int i) {
|
|
LinearSmoothScroller linearSmoothScroller = new LinearSmoothScroller(recyclerView.getContext()) { // from class: com.google.android.material.carousel.CarouselLayoutManager.1
|
|
@Override // androidx.recyclerview.widget.RecyclerView.SmoothScroller
|
|
public PointF computeScrollVectorForPosition(int i2) {
|
|
return CarouselLayoutManager.this.computeScrollVectorForPosition(i2);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.LinearSmoothScroller
|
|
public int calculateDxToMakeVisible(View view, int i2) {
|
|
if (CarouselLayoutManager.this.keylineStateList == null || !CarouselLayoutManager.this.isHorizontal()) {
|
|
return 0;
|
|
}
|
|
CarouselLayoutManager carouselLayoutManager = CarouselLayoutManager.this;
|
|
return carouselLayoutManager.calculateScrollDeltaToMakePositionVisible(carouselLayoutManager.getPosition(view));
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.LinearSmoothScroller
|
|
public int calculateDyToMakeVisible(View view, int i2) {
|
|
if (CarouselLayoutManager.this.keylineStateList == null || CarouselLayoutManager.this.isHorizontal()) {
|
|
return 0;
|
|
}
|
|
CarouselLayoutManager carouselLayoutManager = CarouselLayoutManager.this;
|
|
return carouselLayoutManager.calculateScrollDeltaToMakePositionVisible(carouselLayoutManager.getPosition(view));
|
|
}
|
|
};
|
|
linearSmoothScroller.setTargetPosition(i);
|
|
startSmoothScroll(linearSmoothScroller);
|
|
}
|
|
|
|
int calculateScrollDeltaToMakePositionVisible(int i) {
|
|
return (int) (this.scrollOffset - getScrollOffsetForPosition(i, getKeylineStateForPosition(i)));
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public boolean canScrollHorizontally() {
|
|
return isHorizontal();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int scrollHorizontallyBy(int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
|
|
if (canScrollHorizontally()) {
|
|
return scrollBy(i, recycler, state);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public boolean canScrollVertically() {
|
|
return !isHorizontal();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int scrollVerticallyBy(int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
|
|
if (canScrollVertically()) {
|
|
return scrollBy(i, recycler, state);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private static class LayoutDirection {
|
|
private static final int INVALID_LAYOUT = Integer.MIN_VALUE;
|
|
private static final int LAYOUT_END = 1;
|
|
private static final int LAYOUT_START = -1;
|
|
|
|
private LayoutDirection() {
|
|
}
|
|
}
|
|
|
|
private int convertFocusDirectionToLayoutDirection(int i) {
|
|
int orientation = getOrientation();
|
|
if (i == 1) {
|
|
return -1;
|
|
}
|
|
if (i == 2) {
|
|
return 1;
|
|
}
|
|
if (i == 17) {
|
|
if (orientation == 0) {
|
|
return isLayoutRtl() ? 1 : -1;
|
|
}
|
|
return Integer.MIN_VALUE;
|
|
}
|
|
if (i == 33) {
|
|
return orientation == 1 ? -1 : Integer.MIN_VALUE;
|
|
}
|
|
if (i == 66) {
|
|
if (orientation == 0) {
|
|
return isLayoutRtl() ? -1 : 1;
|
|
}
|
|
return Integer.MIN_VALUE;
|
|
}
|
|
if (i == 130) {
|
|
return orientation == 1 ? 1 : Integer.MIN_VALUE;
|
|
}
|
|
Log.d(TAG, "Unknown focus request:" + i);
|
|
return Integer.MIN_VALUE;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public View onFocusSearchFailed(View view, int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
|
|
int convertFocusDirectionToLayoutDirection;
|
|
if (getChildCount() == 0 || (convertFocusDirectionToLayoutDirection = convertFocusDirectionToLayoutDirection(i)) == Integer.MIN_VALUE) {
|
|
return null;
|
|
}
|
|
if (convertFocusDirectionToLayoutDirection == -1) {
|
|
if (getPosition(view) == 0) {
|
|
return null;
|
|
}
|
|
addViewAtPosition(recycler, getPosition(getChildAt(0)) - 1, 0);
|
|
return getChildClosestToStart();
|
|
}
|
|
if (getPosition(view) == getItemCount() - 1) {
|
|
return null;
|
|
}
|
|
addViewAtPosition(recycler, getPosition(getChildAt(getChildCount() - 1)) + 1, -1);
|
|
return getChildClosestToEnd();
|
|
}
|
|
|
|
private View getChildClosestToStart() {
|
|
return getChildAt(isLayoutRtl() ? getChildCount() - 1 : 0);
|
|
}
|
|
|
|
private View getChildClosestToEnd() {
|
|
return getChildAt(isLayoutRtl() ? 0 : getChildCount() - 1);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public boolean requestChildRectangleOnScreen(RecyclerView recyclerView, View view, Rect rect, boolean z, boolean z2) {
|
|
int smallestScrollOffsetToFocalKeyline;
|
|
if (this.keylineStateList == null || (smallestScrollOffsetToFocalKeyline = getSmallestScrollOffsetToFocalKeyline(getPosition(view), getKeylineStateForPosition(getPosition(view)))) == 0) {
|
|
return false;
|
|
}
|
|
scrollBy(recyclerView, getSmallestScrollOffsetToFocalKeyline(getPosition(view), this.keylineStateList.getShiftedState(this.scrollOffset + calculateShouldScrollBy(smallestScrollOffsetToFocalKeyline, this.scrollOffset, this.minScroll, this.maxScroll), this.minScroll, this.maxScroll)));
|
|
return true;
|
|
}
|
|
|
|
private void scrollBy(RecyclerView recyclerView, int i) {
|
|
if (isHorizontal()) {
|
|
recyclerView.scrollBy(i, 0);
|
|
} else {
|
|
recyclerView.scrollBy(0, i);
|
|
}
|
|
}
|
|
|
|
private int scrollBy(int i, RecyclerView.Recycler recycler, RecyclerView.State state) {
|
|
float f;
|
|
if (getChildCount() == 0 || i == 0) {
|
|
return 0;
|
|
}
|
|
if (this.keylineStateList == null) {
|
|
recalculateKeylineStateList(recycler);
|
|
}
|
|
int calculateShouldScrollBy = calculateShouldScrollBy(i, this.scrollOffset, this.minScroll, this.maxScroll);
|
|
this.scrollOffset += calculateShouldScrollBy;
|
|
updateCurrentKeylineStateForScrollOffset(this.keylineStateList);
|
|
float itemSize = this.currentKeylineState.getItemSize() / 2.0f;
|
|
float calculateChildStartForFill = calculateChildStartForFill(getPosition(getChildAt(0)));
|
|
Rect rect = new Rect();
|
|
if (isLayoutRtl()) {
|
|
f = this.currentKeylineState.getLastFocalKeyline().locOffset;
|
|
} else {
|
|
f = this.currentKeylineState.getFirstFocalKeyline().locOffset;
|
|
}
|
|
float f2 = Float.MAX_VALUE;
|
|
for (int i2 = 0; i2 < getChildCount(); i2++) {
|
|
View childAt = getChildAt(i2);
|
|
float abs = Math.abs(f - offsetChild(childAt, calculateChildStartForFill, itemSize, rect));
|
|
if (childAt != null && abs < f2) {
|
|
this.currentEstimatedPosition = getPosition(childAt);
|
|
f2 = abs;
|
|
}
|
|
calculateChildStartForFill = addEnd(calculateChildStartForFill, this.currentKeylineState.getItemSize());
|
|
}
|
|
fill(recycler, state);
|
|
return calculateShouldScrollBy;
|
|
}
|
|
|
|
private float offsetChild(View view, float f, float f2, Rect rect) {
|
|
float addEnd = addEnd(f, f2);
|
|
KeylineRange surroundingKeylineRange = getSurroundingKeylineRange(this.currentKeylineState.getKeylines(), addEnd, false);
|
|
float calculateChildOffsetCenterForLocation = calculateChildOffsetCenterForLocation(view, addEnd, surroundingKeylineRange);
|
|
super.getDecoratedBoundsWithMargins(view, rect);
|
|
updateChildMaskForLocation(view, addEnd, surroundingKeylineRange);
|
|
this.orientationHelper.offsetChild(view, rect, f2, calculateChildOffsetCenterForLocation);
|
|
return calculateChildOffsetCenterForLocation;
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int computeHorizontalScrollExtent(RecyclerView.State state) {
|
|
if (getChildCount() == 0 || this.keylineStateList == null || getItemCount() <= 1) {
|
|
return 0;
|
|
}
|
|
return (int) (getWidth() * (this.keylineStateList.getDefaultState().getItemSize() / computeHorizontalScrollRange(state)));
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public int computeVerticalScrollExtent(RecyclerView.State state) {
|
|
if (getChildCount() == 0 || this.keylineStateList == null || getItemCount() <= 1) {
|
|
return 0;
|
|
}
|
|
return (int) (getHeight() * (this.keylineStateList.getDefaultState().getItemSize() / computeVerticalScrollRange(state)));
|
|
}
|
|
|
|
public int getOrientation() {
|
|
return this.orientationHelper.orientation;
|
|
}
|
|
|
|
public void setOrientation(int i) {
|
|
if (i != 0 && i != 1) {
|
|
throw new IllegalArgumentException("invalid orientation:" + i);
|
|
}
|
|
assertNotInLayoutOrScroll(null);
|
|
CarouselOrientationHelper carouselOrientationHelper = this.orientationHelper;
|
|
if (carouselOrientationHelper == null || i != carouselOrientationHelper.orientation) {
|
|
this.orientationHelper = CarouselOrientationHelper.createOrientationHelper(this, i);
|
|
refreshKeylineState();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onItemsAdded(RecyclerView recyclerView, int i, int i2) {
|
|
super.onItemsAdded(recyclerView, i, i2);
|
|
updateItemCount();
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.LayoutManager
|
|
public void onItemsRemoved(RecyclerView recyclerView, int i, int i2) {
|
|
super.onItemsRemoved(recyclerView, i, i2);
|
|
updateItemCount();
|
|
}
|
|
|
|
private void updateItemCount() {
|
|
int itemCount = getItemCount();
|
|
int i = this.lastItemCount;
|
|
if (itemCount == i || this.keylineStateList == null) {
|
|
return;
|
|
}
|
|
if (this.carouselStrategy.shouldRefreshKeylineState(this, i)) {
|
|
refreshKeylineState();
|
|
}
|
|
this.lastItemCount = itemCount;
|
|
}
|
|
|
|
public void setDebuggingEnabled(RecyclerView recyclerView, boolean z) {
|
|
this.isDebuggingEnabled = z;
|
|
recyclerView.removeItemDecoration(this.debugItemDecoration);
|
|
if (z) {
|
|
recyclerView.addItemDecoration(this.debugItemDecoration);
|
|
}
|
|
recyclerView.invalidateItemDecorations();
|
|
}
|
|
|
|
private static class KeylineRange {
|
|
final KeylineState.Keyline leftOrTop;
|
|
final KeylineState.Keyline rightOrBottom;
|
|
|
|
KeylineRange(KeylineState.Keyline keyline, KeylineState.Keyline keyline2) {
|
|
Preconditions.checkArgument(keyline.loc <= keyline2.loc);
|
|
this.leftOrTop = keyline;
|
|
this.rightOrBottom = keyline2;
|
|
}
|
|
}
|
|
|
|
private static class DebugItemDecoration extends RecyclerView.ItemDecoration {
|
|
private List<KeylineState.Keyline> keylines;
|
|
private final Paint linePaint;
|
|
|
|
DebugItemDecoration() {
|
|
Paint paint = new Paint();
|
|
this.linePaint = paint;
|
|
this.keylines = Collections.unmodifiableList(new ArrayList());
|
|
paint.setStrokeWidth(5.0f);
|
|
paint.setColor(-65281);
|
|
}
|
|
|
|
void setKeylines(List<KeylineState.Keyline> list) {
|
|
this.keylines = Collections.unmodifiableList(list);
|
|
}
|
|
|
|
@Override // androidx.recyclerview.widget.RecyclerView.ItemDecoration
|
|
public void onDrawOver(Canvas canvas, RecyclerView recyclerView, RecyclerView.State state) {
|
|
super.onDrawOver(canvas, recyclerView, state);
|
|
this.linePaint.setStrokeWidth(recyclerView.getResources().getDimension(R.dimen.m3_carousel_debug_keyline_width));
|
|
for (KeylineState.Keyline keyline : this.keylines) {
|
|
this.linePaint.setColor(ColorUtils.blendARGB(-65281, -16776961, keyline.mask));
|
|
if (((CarouselLayoutManager) recyclerView.getLayoutManager()).isHorizontal()) {
|
|
canvas.drawLine(keyline.locOffset, ((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentTop(), keyline.locOffset, ((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentBottom(), this.linePaint);
|
|
} else {
|
|
canvas.drawLine(((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentLeft(), keyline.locOffset, ((CarouselLayoutManager) recyclerView.getLayoutManager()).getParentRight(), keyline.locOffset, this.linePaint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|