ADD week 5

02-Easy5/E5/sources/com/google/android/material/shape/AbsoluteCornerSize.java

@@ -0,0 +1,33 @@
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class AbsoluteCornerSize implements CornerSize {
+    private final float size;
+
+    public float getCornerSize() {
+        return this.size;
+    }
+
+    @Override // com.google.android.material.shape.CornerSize
+    public float getCornerSize(RectF rectF) {
+        return this.size;
+    }
+
+    public AbsoluteCornerSize(float f) {
+        this.size = f;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        return (obj instanceof AbsoluteCornerSize) && this.size == ((AbsoluteCornerSize) obj).size;
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(new Object[]{Float.valueOf(this.size)});
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/AdjustedCornerSize.java

@@ -0,0 +1,39 @@
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class AdjustedCornerSize implements CornerSize {
+    private final float adjustment;
+    private final CornerSize other;
+
+    public AdjustedCornerSize(float f, CornerSize cornerSize) {
+        while (cornerSize instanceof AdjustedCornerSize) {
+            cornerSize = ((AdjustedCornerSize) cornerSize).other;
+            f += ((AdjustedCornerSize) cornerSize).adjustment;
+        }
+        this.other = cornerSize;
+        this.adjustment = f;
+    }
+
+    @Override // com.google.android.material.shape.CornerSize
+    public float getCornerSize(RectF rectF) {
+        return Math.max(0.0f, this.other.getCornerSize(rectF) + this.adjustment);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof AdjustedCornerSize)) {
+            return false;
+        }
+        AdjustedCornerSize adjustedCornerSize = (AdjustedCornerSize) obj;
+        return this.other.equals(adjustedCornerSize.other) && this.adjustment == adjustedCornerSize.adjustment;
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(new Object[]{this.other, Float.valueOf(this.adjustment)});
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ClampedCornerSize.java

@@ -0,0 +1,37 @@
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class ClampedCornerSize implements CornerSize {
+    private final float target;
+
+    public static ClampedCornerSize createFromCornerSize(AbsoluteCornerSize absoluteCornerSize) {
+        return new ClampedCornerSize(absoluteCornerSize.getCornerSize());
+    }
+
+    private static float getMaxCornerSize(RectF rectF) {
+        return Math.min(rectF.width() / 2.0f, rectF.height() / 2.0f);
+    }
+
+    public ClampedCornerSize(float f) {
+        this.target = f;
+    }
+
+    @Override // com.google.android.material.shape.CornerSize
+    public float getCornerSize(RectF rectF) {
+        return Math.min(this.target, getMaxCornerSize(rectF));
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        return (obj instanceof ClampedCornerSize) && this.target == ((ClampedCornerSize) obj).target;
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(new Object[]{Float.valueOf(this.target)});
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/CornerFamily.java

@@ -0,0 +1,11 @@
+package com.google.android.material.shape;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.SOURCE)
+/* loaded from: classes.dex */
+public @interface CornerFamily {
+    public static final int CUT = 1;
+    public static final int ROUNDED = 0;
+}

02-Easy5/E5/sources/com/google/android/material/shape/CornerSize.java

@@ -0,0 +1,8 @@
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+
+/* loaded from: classes.dex */
+public interface CornerSize {
+    float getCornerSize(RectF rectF);
+}

02-Easy5/E5/sources/com/google/android/material/shape/CornerTreatment.java

@@ -0,0 +1,18 @@
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+
+/* loaded from: classes.dex */
+public class CornerTreatment {
+    @Deprecated
+    public void getCornerPath(float f, float f2, ShapePath shapePath) {
+    }
+
+    public void getCornerPath(ShapePath shapePath, float f, float f2, float f3) {
+        getCornerPath(f, f2, shapePath);
+    }
+
+    public void getCornerPath(ShapePath shapePath, float f, float f2, RectF rectF, CornerSize cornerSize) {
+        getCornerPath(shapePath, f, f2, cornerSize.getCornerSize(rectF));
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/CutCornerTreatment.java

@@ -0,0 +1,23 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public class CutCornerTreatment extends CornerTreatment {
+    float size;
+
+    public CutCornerTreatment() {
+        this.size = -1.0f;
+    }
+
+    @Deprecated
+    public CutCornerTreatment(float f) {
+        this.size = f;
+    }
+
+    @Override // com.google.android.material.shape.CornerTreatment
+    public void getCornerPath(ShapePath shapePath, float f, float f2, float f3) {
+        shapePath.reset(0.0f, f3 * f2, 180.0f, 180.0f - f);
+        double d = f3;
+        double d2 = f2;
+        shapePath.lineTo((float) (Math.sin(Math.toRadians(f)) * d * d2), (float) (Math.sin(Math.toRadians(90.0f - f)) * d * d2));
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/EdgeTreatment.java

@@ -0,0 +1,17 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public class EdgeTreatment {
+    boolean forceIntersection() {
+        return false;
+    }
+
+    @Deprecated
+    public void getEdgePath(float f, float f2, ShapePath shapePath) {
+        getEdgePath(f, f / 2.0f, f2, shapePath);
+    }
+
+    public void getEdgePath(float f, float f2, float f3, ShapePath shapePath) {
+        shapePath.lineTo(f, 0.0f);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/InterpolateOnScrollPositionChangeHelper.java

@@ -0,0 +1,69 @@
+package com.google.android.material.shape;
+
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.widget.ScrollView;
+
+/* loaded from: classes.dex */
+public class InterpolateOnScrollPositionChangeHelper {
+    private ScrollView containingScrollView;
+    private MaterialShapeDrawable materialShapeDrawable;
+    private View shapedView;
+    private final int[] scrollLocation = new int[2];
+    private final int[] containerLocation = new int[2];
+    private final ViewTreeObserver.OnScrollChangedListener scrollChangedListener = new ViewTreeObserver.OnScrollChangedListener() { // from class: com.google.android.material.shape.InterpolateOnScrollPositionChangeHelper.1
+        @Override // android.view.ViewTreeObserver.OnScrollChangedListener
+        public void onScrollChanged() {
+            InterpolateOnScrollPositionChangeHelper.this.updateInterpolationForScreenPosition();
+        }
+    };
+
+    public void setContainingScrollView(ScrollView scrollView) {
+        this.containingScrollView = scrollView;
+    }
+
+    public void setMaterialShapeDrawable(MaterialShapeDrawable materialShapeDrawable) {
+        this.materialShapeDrawable = materialShapeDrawable;
+    }
+
+    public InterpolateOnScrollPositionChangeHelper(View view, MaterialShapeDrawable materialShapeDrawable, ScrollView scrollView) {
+        this.shapedView = view;
+        this.materialShapeDrawable = materialShapeDrawable;
+        this.containingScrollView = scrollView;
+    }
+
+    public void startListeningForScrollChanges(ViewTreeObserver viewTreeObserver) {
+        viewTreeObserver.addOnScrollChangedListener(this.scrollChangedListener);
+    }
+
+    public void stopListeningForScrollChanges(ViewTreeObserver viewTreeObserver) {
+        viewTreeObserver.removeOnScrollChangedListener(this.scrollChangedListener);
+    }
+
+    public void updateInterpolationForScreenPosition() {
+        ScrollView scrollView = this.containingScrollView;
+        if (scrollView == null) {
+            return;
+        }
+        if (scrollView.getChildCount() == 0) {
+            throw new IllegalStateException("Scroll bar must contain a child to calculate interpolation.");
+        }
+        this.containingScrollView.getLocationInWindow(this.scrollLocation);
+        this.containingScrollView.getChildAt(0).getLocationInWindow(this.containerLocation);
+        int top = (this.shapedView.getTop() - this.scrollLocation[1]) + this.containerLocation[1];
+        int height = this.shapedView.getHeight();
+        int height2 = this.containingScrollView.getHeight();
+        if (top < 0) {
+            this.materialShapeDrawable.setInterpolation(Math.max(0.0f, Math.min(1.0f, (top / height) + 1.0f)));
+            this.shapedView.invalidate();
+            return;
+        }
+        if (top + height > height2) {
+            this.materialShapeDrawable.setInterpolation(Math.max(0.0f, Math.min(1.0f, 1.0f - ((r0 - height2) / height))));
+            this.shapedView.invalidate();
+        } else if (this.materialShapeDrawable.getInterpolation() != 1.0f) {
+            this.materialShapeDrawable.setInterpolation(1.0f);
+            this.shapedView.invalidate();
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/MarkerEdgeTreatment.java

@@ -0,0 +1,24 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public final class MarkerEdgeTreatment extends EdgeTreatment {
+    private final float radius;
+
+    @Override // com.google.android.material.shape.EdgeTreatment
+    boolean forceIntersection() {
+        return true;
+    }
+
+    public MarkerEdgeTreatment(float f) {
+        this.radius = f - 0.001f;
+    }
+
+    @Override // com.google.android.material.shape.EdgeTreatment
+    public void getEdgePath(float f, float f2, float f3, ShapePath shapePath) {
+        float sqrt = (float) ((this.radius * Math.sqrt(2.0d)) / 2.0d);
+        float sqrt2 = (float) Math.sqrt(Math.pow(this.radius, 2.0d) - Math.pow(sqrt, 2.0d));
+        shapePath.reset(f2 - sqrt, ((float) (-((this.radius * Math.sqrt(2.0d)) - this.radius))) + sqrt2);
+        shapePath.lineTo(f2, (float) (-((this.radius * Math.sqrt(2.0d)) - this.radius)));
+        shapePath.lineTo(f2 + sqrt, ((float) (-((this.radius * Math.sqrt(2.0d)) - this.radius))) + sqrt2);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/MaterialShapeDrawable.java

@@ -0,0 +1,926 @@
+package com.google.android.material.shape;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Matrix;
+import android.graphics.Outline;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Region;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.os.Looper;
+import android.util.AttributeSet;
+import android.util.Log;
+import androidx.core.graphics.drawable.TintAwareDrawable;
+import androidx.core.util.ObjectsCompat;
+import com.google.android.material.R;
+import com.google.android.material.color.MaterialColors;
+import com.google.android.material.drawable.DrawableUtils;
+import com.google.android.material.elevation.ElevationOverlayProvider;
+import com.google.android.material.shadow.ShadowRenderer;
+import com.google.android.material.shape.ShapeAppearanceModel;
+import com.google.android.material.shape.ShapeAppearancePathProvider;
+import com.google.android.material.shape.ShapePath;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.BitSet;
+
+/* loaded from: classes.dex */
+public class MaterialShapeDrawable extends Drawable implements TintAwareDrawable, Shapeable {
+    public static final int SHADOW_COMPAT_MODE_ALWAYS = 2;
+    public static final int SHADOW_COMPAT_MODE_DEFAULT = 0;
+    public static final int SHADOW_COMPAT_MODE_NEVER = 1;
+    private static final float SHADOW_OFFSET_MULTIPLIER = 0.25f;
+    private static final float SHADOW_RADIUS_MULTIPLIER = 0.75f;
+    private static final String TAG = "MaterialShapeDrawable";
+    private static final Paint clearPaint;
+    private final BitSet containsIncompatibleShadowOp;
+    private final ShapePath.ShadowCompatOperation[] cornerShadowOperation;
+    private MaterialShapeDrawableState drawableState;
+    private final ShapePath.ShadowCompatOperation[] edgeShadowOperation;
+    private final Paint fillPaint;
+    private final RectF insetRectF;
+    private final Matrix matrix;
+    private final Path path;
+    private final RectF pathBounds;
+    private boolean pathDirty;
+    private final Path pathInsetByStroke;
+    private final ShapeAppearancePathProvider pathProvider;
+    private final ShapeAppearancePathProvider.PathListener pathShadowListener;
+    private final RectF rectF;
+    private int resolvedTintColor;
+    private final Region scratchRegion;
+    private boolean shadowBitmapDrawingEnable;
+    private final ShadowRenderer shadowRenderer;
+    private final Paint strokePaint;
+    private ShapeAppearanceModel strokeShapeAppearance;
+    private PorterDuffColorFilter strokeTintFilter;
+    private PorterDuffColorFilter tintFilter;
+    private final Region transparentRegion;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface CompatibilityShadowMode {
+    }
+
+    private static int modulateAlpha(int i, int i2) {
+        return (i * (i2 + (i2 >>> 7))) >>> 8;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public Drawable.ConstantState getConstantState() {
+        return this.drawableState;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public int getOpacity() {
+        return -3;
+    }
+
+    public int getResolvedTintColor() {
+        return this.resolvedTintColor;
+    }
+
+    public void setShadowBitmapDrawingEnable(boolean z) {
+        this.shadowBitmapDrawingEnable = z;
+    }
+
+    static {
+        Paint paint = new Paint(1);
+        clearPaint = paint;
+        paint.setColor(-1);
+        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
+    }
+
+    public static MaterialShapeDrawable createWithElevationOverlay(Context context) {
+        return createWithElevationOverlay(context, 0.0f);
+    }
+
+    public static MaterialShapeDrawable createWithElevationOverlay(Context context, float f) {
+        return createWithElevationOverlay(context, f, null);
+    }
+
+    public static MaterialShapeDrawable createWithElevationOverlay(Context context, float f, ColorStateList colorStateList) {
+        if (colorStateList == null) {
+            colorStateList = ColorStateList.valueOf(MaterialColors.getColor(context, R.attr.colorSurface, TAG));
+        }
+        MaterialShapeDrawable materialShapeDrawable = new MaterialShapeDrawable();
+        materialShapeDrawable.initializeElevationOverlay(context);
+        materialShapeDrawable.setFillColor(colorStateList);
+        materialShapeDrawable.setElevation(f);
+        return materialShapeDrawable;
+    }
+
+    public MaterialShapeDrawable() {
+        this(new ShapeAppearanceModel());
+    }
+
+    public MaterialShapeDrawable(Context context, AttributeSet attributeSet, int i, int i2) {
+        this(ShapeAppearanceModel.builder(context, attributeSet, i, i2).build());
+    }
+
+    @Deprecated
+    public MaterialShapeDrawable(ShapePathModel shapePathModel) {
+        this((ShapeAppearanceModel) shapePathModel);
+    }
+
+    public MaterialShapeDrawable(ShapeAppearanceModel shapeAppearanceModel) {
+        this(new MaterialShapeDrawableState(shapeAppearanceModel, null));
+    }
+
+    protected MaterialShapeDrawable(MaterialShapeDrawableState materialShapeDrawableState) {
+        ShapeAppearancePathProvider shapeAppearancePathProvider;
+        this.cornerShadowOperation = new ShapePath.ShadowCompatOperation[4];
+        this.edgeShadowOperation = new ShapePath.ShadowCompatOperation[4];
+        this.containsIncompatibleShadowOp = new BitSet(8);
+        this.matrix = new Matrix();
+        this.path = new Path();
+        this.pathInsetByStroke = new Path();
+        this.rectF = new RectF();
+        this.insetRectF = new RectF();
+        this.transparentRegion = new Region();
+        this.scratchRegion = new Region();
+        Paint paint = new Paint(1);
+        this.fillPaint = paint;
+        Paint paint2 = new Paint(1);
+        this.strokePaint = paint2;
+        this.shadowRenderer = new ShadowRenderer();
+        if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
+            shapeAppearancePathProvider = ShapeAppearancePathProvider.getInstance();
+        } else {
+            shapeAppearancePathProvider = new ShapeAppearancePathProvider();
+        }
+        this.pathProvider = shapeAppearancePathProvider;
+        this.pathBounds = new RectF();
+        this.shadowBitmapDrawingEnable = true;
+        this.drawableState = materialShapeDrawableState;
+        paint2.setStyle(Paint.Style.STROKE);
+        paint.setStyle(Paint.Style.FILL);
+        updateTintFilter();
+        updateColorsForState(getState());
+        this.pathShadowListener = new ShapeAppearancePathProvider.PathListener() { // from class: com.google.android.material.shape.MaterialShapeDrawable.1
+            @Override // com.google.android.material.shape.ShapeAppearancePathProvider.PathListener
+            public void onCornerPathCreated(ShapePath shapePath, Matrix matrix, int i) {
+                MaterialShapeDrawable.this.containsIncompatibleShadowOp.set(i, shapePath.containsIncompatibleShadowOp());
+                MaterialShapeDrawable.this.cornerShadowOperation[i] = shapePath.createShadowCompatOperation(matrix);
+            }
+
+            @Override // com.google.android.material.shape.ShapeAppearancePathProvider.PathListener
+            public void onEdgePathCreated(ShapePath shapePath, Matrix matrix, int i) {
+                MaterialShapeDrawable.this.containsIncompatibleShadowOp.set(i + 4, shapePath.containsIncompatibleShadowOp());
+                MaterialShapeDrawable.this.edgeShadowOperation[i] = shapePath.createShadowCompatOperation(matrix);
+            }
+        };
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public Drawable mutate() {
+        this.drawableState = new MaterialShapeDrawableState(this.drawableState);
+        return this;
+    }
+
+    @Override // com.google.android.material.shape.Shapeable
+    public void setShapeAppearanceModel(ShapeAppearanceModel shapeAppearanceModel) {
+        this.drawableState.shapeAppearanceModel = shapeAppearanceModel;
+        invalidateSelf();
+    }
+
+    @Override // com.google.android.material.shape.Shapeable
+    public ShapeAppearanceModel getShapeAppearanceModel() {
+        return this.drawableState.shapeAppearanceModel;
+    }
+
+    @Deprecated
+    public void setShapedViewModel(ShapePathModel shapePathModel) {
+        setShapeAppearanceModel(shapePathModel);
+    }
+
+    @Deprecated
+    public ShapePathModel getShapedViewModel() {
+        ShapeAppearanceModel shapeAppearanceModel = getShapeAppearanceModel();
+        if (shapeAppearanceModel instanceof ShapePathModel) {
+            return (ShapePathModel) shapeAppearanceModel;
+        }
+        return null;
+    }
+
+    public void setFillColor(ColorStateList colorStateList) {
+        if (this.drawableState.fillColor != colorStateList) {
+            this.drawableState.fillColor = colorStateList;
+            onStateChange(getState());
+        }
+    }
+
+    public ColorStateList getFillColor() {
+        return this.drawableState.fillColor;
+    }
+
+    public void setStrokeColor(ColorStateList colorStateList) {
+        if (this.drawableState.strokeColor != colorStateList) {
+            this.drawableState.strokeColor = colorStateList;
+            onStateChange(getState());
+        }
+    }
+
+    public ColorStateList getStrokeColor() {
+        return this.drawableState.strokeColor;
+    }
+
+    @Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable
+    public void setTintMode(PorterDuff.Mode mode) {
+        if (this.drawableState.tintMode != mode) {
+            this.drawableState.tintMode = mode;
+            updateTintFilter();
+            invalidateSelfIgnoreShape();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable
+    public void setTintList(ColorStateList colorStateList) {
+        this.drawableState.tintList = colorStateList;
+        updateTintFilter();
+        invalidateSelfIgnoreShape();
+    }
+
+    public ColorStateList getTintList() {
+        return this.drawableState.tintList;
+    }
+
+    public ColorStateList getStrokeTintList() {
+        return this.drawableState.strokeTintList;
+    }
+
+    @Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable
+    public void setTint(int i) {
+        setTintList(ColorStateList.valueOf(i));
+    }
+
+    public void setStrokeTint(ColorStateList colorStateList) {
+        this.drawableState.strokeTintList = colorStateList;
+        updateTintFilter();
+        invalidateSelfIgnoreShape();
+    }
+
+    public void setStrokeTint(int i) {
+        setStrokeTint(ColorStateList.valueOf(i));
+    }
+
+    public void setStroke(float f, int i) {
+        setStrokeWidth(f);
+        setStrokeColor(ColorStateList.valueOf(i));
+    }
+
+    public void setStroke(float f, ColorStateList colorStateList) {
+        setStrokeWidth(f);
+        setStrokeColor(colorStateList);
+    }
+
+    public float getStrokeWidth() {
+        return this.drawableState.strokeWidth;
+    }
+
+    public void setStrokeWidth(float f) {
+        this.drawableState.strokeWidth = f;
+        invalidateSelf();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public int getAlpha() {
+        return this.drawableState.alpha;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public void setAlpha(int i) {
+        if (this.drawableState.alpha != i) {
+            this.drawableState.alpha = i;
+            invalidateSelfIgnoreShape();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public void setColorFilter(ColorFilter colorFilter) {
+        this.drawableState.colorFilter = colorFilter;
+        invalidateSelfIgnoreShape();
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public Region getTransparentRegion() {
+        this.transparentRegion.set(getBounds());
+        calculatePath(getBoundsAsRectF(), this.path);
+        this.scratchRegion.setPath(this.path, this.transparentRegion);
+        this.transparentRegion.op(this.scratchRegion, Region.Op.DIFFERENCE);
+        return this.transparentRegion;
+    }
+
+    protected RectF getBoundsAsRectF() {
+        this.rectF.set(getBounds());
+        return this.rectF;
+    }
+
+    public void setCornerSize(float f) {
+        setShapeAppearanceModel(this.drawableState.shapeAppearanceModel.withCornerSize(f));
+    }
+
+    public void setCornerSize(CornerSize cornerSize) {
+        setShapeAppearanceModel(this.drawableState.shapeAppearanceModel.withCornerSize(cornerSize));
+    }
+
+    public boolean isPointInTransparentRegion(int i, int i2) {
+        return getTransparentRegion().contains(i, i2);
+    }
+
+    public int getShadowCompatibilityMode() {
+        return this.drawableState.shadowCompatMode;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public boolean getPadding(Rect rect) {
+        if (this.drawableState.padding != null) {
+            rect.set(this.drawableState.padding);
+            return true;
+        }
+        return super.getPadding(rect);
+    }
+
+    public void setPadding(int i, int i2, int i3, int i4) {
+        if (this.drawableState.padding == null) {
+            this.drawableState.padding = new Rect();
+        }
+        this.drawableState.padding.set(i, i2, i3, i4);
+        invalidateSelf();
+    }
+
+    public void setShadowCompatibilityMode(int i) {
+        if (this.drawableState.shadowCompatMode != i) {
+            this.drawableState.shadowCompatMode = i;
+            invalidateSelfIgnoreShape();
+        }
+    }
+
+    @Deprecated
+    public boolean isShadowEnabled() {
+        return this.drawableState.shadowCompatMode == 0 || this.drawableState.shadowCompatMode == 2;
+    }
+
+    @Deprecated
+    public void setShadowEnabled(boolean z) {
+        setShadowCompatibilityMode(!z ? 1 : 0);
+    }
+
+    public boolean isElevationOverlayEnabled() {
+        return this.drawableState.elevationOverlayProvider != null && this.drawableState.elevationOverlayProvider.isThemeElevationOverlayEnabled();
+    }
+
+    public boolean isElevationOverlayInitialized() {
+        return this.drawableState.elevationOverlayProvider != null;
+    }
+
+    public void initializeElevationOverlay(Context context) {
+        this.drawableState.elevationOverlayProvider = new ElevationOverlayProvider(context);
+        updateZ();
+    }
+
+    protected int compositeElevationOverlayIfNeeded(int i) {
+        return this.drawableState.elevationOverlayProvider != null ? this.drawableState.elevationOverlayProvider.compositeOverlayIfNeeded(i, getZ() + getParentAbsoluteElevation()) : i;
+    }
+
+    public float getInterpolation() {
+        return this.drawableState.interpolation;
+    }
+
+    public void setInterpolation(float f) {
+        if (this.drawableState.interpolation != f) {
+            this.drawableState.interpolation = f;
+            this.pathDirty = true;
+            invalidateSelf();
+        }
+    }
+
+    public float getParentAbsoluteElevation() {
+        return this.drawableState.parentAbsoluteElevation;
+    }
+
+    public void setParentAbsoluteElevation(float f) {
+        if (this.drawableState.parentAbsoluteElevation != f) {
+            this.drawableState.parentAbsoluteElevation = f;
+            updateZ();
+        }
+    }
+
+    public float getElevation() {
+        return this.drawableState.elevation;
+    }
+
+    public void setElevation(float f) {
+        if (this.drawableState.elevation != f) {
+            this.drawableState.elevation = f;
+            updateZ();
+        }
+    }
+
+    public float getTranslationZ() {
+        return this.drawableState.translationZ;
+    }
+
+    public void setTranslationZ(float f) {
+        if (this.drawableState.translationZ != f) {
+            this.drawableState.translationZ = f;
+            updateZ();
+        }
+    }
+
+    public float getZ() {
+        return getElevation() + getTranslationZ();
+    }
+
+    public void setZ(float f) {
+        setTranslationZ(f - getElevation());
+    }
+
+    private void updateZ() {
+        float z = getZ();
+        this.drawableState.shadowCompatRadius = (int) Math.ceil(0.75f * z);
+        this.drawableState.shadowCompatOffset = (int) Math.ceil(z * SHADOW_OFFSET_MULTIPLIER);
+        updateTintFilter();
+        invalidateSelfIgnoreShape();
+    }
+
+    @Deprecated
+    public int getShadowElevation() {
+        return (int) getElevation();
+    }
+
+    @Deprecated
+    public void setShadowElevation(int i) {
+        setElevation(i);
+    }
+
+    public int getShadowVerticalOffset() {
+        return this.drawableState.shadowCompatOffset;
+    }
+
+    public void setEdgeIntersectionCheckEnable(boolean z) {
+        this.pathProvider.setEdgeIntersectionCheckEnable(z);
+    }
+
+    public void setShadowVerticalOffset(int i) {
+        if (this.drawableState.shadowCompatOffset != i) {
+            this.drawableState.shadowCompatOffset = i;
+            invalidateSelfIgnoreShape();
+        }
+    }
+
+    public int getShadowCompatRotation() {
+        return this.drawableState.shadowCompatRotation;
+    }
+
+    public void setShadowCompatRotation(int i) {
+        if (this.drawableState.shadowCompatRotation != i) {
+            this.drawableState.shadowCompatRotation = i;
+            invalidateSelfIgnoreShape();
+        }
+    }
+
+    public int getShadowRadius() {
+        return this.drawableState.shadowCompatRadius;
+    }
+
+    @Deprecated
+    public void setShadowRadius(int i) {
+        this.drawableState.shadowCompatRadius = i;
+    }
+
+    public boolean requiresCompatShadow() {
+        return (isRoundRect() || this.path.isConvex() || Build.VERSION.SDK_INT >= 29) ? false : true;
+    }
+
+    public float getScale() {
+        return this.drawableState.scale;
+    }
+
+    public void setScale(float f) {
+        if (this.drawableState.scale != f) {
+            this.drawableState.scale = f;
+            invalidateSelf();
+        }
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public void invalidateSelf() {
+        this.pathDirty = true;
+        super.invalidateSelf();
+    }
+
+    private void invalidateSelfIgnoreShape() {
+        super.invalidateSelf();
+    }
+
+    public void setUseTintColorForShadow(boolean z) {
+        if (this.drawableState.useTintColorForShadow != z) {
+            this.drawableState.useTintColorForShadow = z;
+            invalidateSelf();
+        }
+    }
+
+    public void setShadowColor(int i) {
+        this.shadowRenderer.setShadowColor(i);
+        this.drawableState.useTintColorForShadow = false;
+        invalidateSelfIgnoreShape();
+    }
+
+    public Paint.Style getPaintStyle() {
+        return this.drawableState.paintStyle;
+    }
+
+    public void setPaintStyle(Paint.Style style) {
+        this.drawableState.paintStyle = style;
+        invalidateSelfIgnoreShape();
+    }
+
+    private boolean hasCompatShadow() {
+        return this.drawableState.shadowCompatMode != 1 && this.drawableState.shadowCompatRadius > 0 && (this.drawableState.shadowCompatMode == 2 || requiresCompatShadow());
+    }
+
+    private boolean hasFill() {
+        return this.drawableState.paintStyle == Paint.Style.FILL_AND_STROKE || this.drawableState.paintStyle == Paint.Style.FILL;
+    }
+
+    private boolean hasStroke() {
+        return (this.drawableState.paintStyle == Paint.Style.FILL_AND_STROKE || this.drawableState.paintStyle == Paint.Style.STROKE) && this.strokePaint.getStrokeWidth() > 0.0f;
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    protected void onBoundsChange(Rect rect) {
+        this.pathDirty = true;
+        super.onBoundsChange(rect);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public void draw(Canvas canvas) {
+        this.fillPaint.setColorFilter(this.tintFilter);
+        int alpha = this.fillPaint.getAlpha();
+        this.fillPaint.setAlpha(modulateAlpha(alpha, this.drawableState.alpha));
+        this.strokePaint.setColorFilter(this.strokeTintFilter);
+        this.strokePaint.setStrokeWidth(this.drawableState.strokeWidth);
+        int alpha2 = this.strokePaint.getAlpha();
+        this.strokePaint.setAlpha(modulateAlpha(alpha2, this.drawableState.alpha));
+        if (this.pathDirty) {
+            calculateStrokePath();
+            calculatePath(getBoundsAsRectF(), this.path);
+            this.pathDirty = false;
+        }
+        maybeDrawCompatShadow(canvas);
+        if (hasFill()) {
+            drawFillShape(canvas);
+        }
+        if (hasStroke()) {
+            drawStrokeShape(canvas);
+        }
+        this.fillPaint.setAlpha(alpha);
+        this.strokePaint.setAlpha(alpha2);
+    }
+
+    private void maybeDrawCompatShadow(Canvas canvas) {
+        if (hasCompatShadow()) {
+            canvas.save();
+            prepareCanvasForShadow(canvas);
+            if (!this.shadowBitmapDrawingEnable) {
+                drawCompatShadow(canvas);
+                canvas.restore();
+                return;
+            }
+            int width = (int) (this.pathBounds.width() - getBounds().width());
+            int height = (int) (this.pathBounds.height() - getBounds().height());
+            if (width < 0 || height < 0) {
+                throw new IllegalStateException("Invalid shadow bounds. Check that the treatments result in a valid path.");
+            }
+            Bitmap createBitmap = Bitmap.createBitmap(((int) this.pathBounds.width()) + (this.drawableState.shadowCompatRadius * 2) + width, ((int) this.pathBounds.height()) + (this.drawableState.shadowCompatRadius * 2) + height, Bitmap.Config.ARGB_8888);
+            Canvas canvas2 = new Canvas(createBitmap);
+            float f = (getBounds().left - this.drawableState.shadowCompatRadius) - width;
+            float f2 = (getBounds().top - this.drawableState.shadowCompatRadius) - height;
+            canvas2.translate(-f, -f2);
+            drawCompatShadow(canvas2);
+            canvas.drawBitmap(createBitmap, f, f2, (Paint) null);
+            createBitmap.recycle();
+            canvas.restore();
+        }
+    }
+
+    protected void drawShape(Canvas canvas, Paint paint, Path path, RectF rectF) {
+        drawShape(canvas, paint, path, this.drawableState.shapeAppearanceModel, rectF);
+    }
+
+    private void drawShape(Canvas canvas, Paint paint, Path path, ShapeAppearanceModel shapeAppearanceModel, RectF rectF) {
+        if (shapeAppearanceModel.isRoundRect(rectF)) {
+            float cornerSize = shapeAppearanceModel.getTopRightCornerSize().getCornerSize(rectF) * this.drawableState.interpolation;
+            canvas.drawRoundRect(rectF, cornerSize, cornerSize, paint);
+        } else {
+            canvas.drawPath(path, paint);
+        }
+    }
+
+    private void drawFillShape(Canvas canvas) {
+        drawShape(canvas, this.fillPaint, this.path, this.drawableState.shapeAppearanceModel, getBoundsAsRectF());
+    }
+
+    protected void drawStrokeShape(Canvas canvas) {
+        drawShape(canvas, this.strokePaint, this.pathInsetByStroke, this.strokeShapeAppearance, getBoundsInsetByStroke());
+    }
+
+    private void prepareCanvasForShadow(Canvas canvas) {
+        canvas.translate(getShadowOffsetX(), getShadowOffsetY());
+    }
+
+    private void drawCompatShadow(Canvas canvas) {
+        if (this.containsIncompatibleShadowOp.cardinality() > 0) {
+            Log.w(TAG, "Compatibility shadow requested but can't be drawn for all operations in this shape.");
+        }
+        if (this.drawableState.shadowCompatOffset != 0) {
+            canvas.drawPath(this.path, this.shadowRenderer.getShadowPaint());
+        }
+        for (int i = 0; i < 4; i++) {
+            this.cornerShadowOperation[i].draw(this.shadowRenderer, this.drawableState.shadowCompatRadius, canvas);
+            this.edgeShadowOperation[i].draw(this.shadowRenderer, this.drawableState.shadowCompatRadius, canvas);
+        }
+        if (this.shadowBitmapDrawingEnable) {
+            int shadowOffsetX = getShadowOffsetX();
+            int shadowOffsetY = getShadowOffsetY();
+            canvas.translate(-shadowOffsetX, -shadowOffsetY);
+            canvas.drawPath(this.path, clearPaint);
+            canvas.translate(shadowOffsetX, shadowOffsetY);
+        }
+    }
+
+    public int getShadowOffsetX() {
+        return (int) (this.drawableState.shadowCompatOffset * Math.sin(Math.toRadians(this.drawableState.shadowCompatRotation)));
+    }
+
+    public int getShadowOffsetY() {
+        return (int) (this.drawableState.shadowCompatOffset * Math.cos(Math.toRadians(this.drawableState.shadowCompatRotation)));
+    }
+
+    @Deprecated
+    public void getPathForSize(int i, int i2, Path path) {
+        calculatePathForSize(new RectF(0.0f, 0.0f, i, i2), path);
+    }
+
+    protected final void calculatePathForSize(RectF rectF, Path path) {
+        this.pathProvider.calculatePath(this.drawableState.shapeAppearanceModel, this.drawableState.interpolation, rectF, this.pathShadowListener, path);
+    }
+
+    private void calculateStrokePath() {
+        final float f = -getStrokeInsetLength();
+        ShapeAppearanceModel withTransformedCornerSizes = getShapeAppearanceModel().withTransformedCornerSizes(new ShapeAppearanceModel.CornerSizeUnaryOperator() { // from class: com.google.android.material.shape.MaterialShapeDrawable.2
+            @Override // com.google.android.material.shape.ShapeAppearanceModel.CornerSizeUnaryOperator
+            public CornerSize apply(CornerSize cornerSize) {
+                return cornerSize instanceof RelativeCornerSize ? cornerSize : new AdjustedCornerSize(f, cornerSize);
+            }
+        });
+        this.strokeShapeAppearance = withTransformedCornerSizes;
+        this.pathProvider.calculatePath(withTransformedCornerSizes, this.drawableState.interpolation, getBoundsInsetByStroke(), this.pathInsetByStroke);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public void getOutline(Outline outline) {
+        if (this.drawableState.shadowCompatMode == 2) {
+            return;
+        }
+        if (isRoundRect()) {
+            outline.setRoundRect(getBounds(), getTopLeftCornerResolvedSize() * this.drawableState.interpolation);
+        } else {
+            calculatePath(getBoundsAsRectF(), this.path);
+            DrawableUtils.setOutlineToPath(outline, this.path);
+        }
+    }
+
+    private void calculatePath(RectF rectF, Path path) {
+        calculatePathForSize(rectF, path);
+        if (this.drawableState.scale != 1.0f) {
+            this.matrix.reset();
+            this.matrix.setScale(this.drawableState.scale, this.drawableState.scale, rectF.width() / 2.0f, rectF.height() / 2.0f);
+            path.transform(this.matrix);
+        }
+        path.computeBounds(this.pathBounds, true);
+    }
+
+    private boolean updateTintFilter() {
+        PorterDuffColorFilter porterDuffColorFilter = this.tintFilter;
+        PorterDuffColorFilter porterDuffColorFilter2 = this.strokeTintFilter;
+        this.tintFilter = calculateTintFilter(this.drawableState.tintList, this.drawableState.tintMode, this.fillPaint, true);
+        this.strokeTintFilter = calculateTintFilter(this.drawableState.strokeTintList, this.drawableState.tintMode, this.strokePaint, false);
+        if (this.drawableState.useTintColorForShadow) {
+            this.shadowRenderer.setShadowColor(this.drawableState.tintList.getColorForState(getState(), 0));
+        }
+        return (ObjectsCompat.equals(porterDuffColorFilter, this.tintFilter) && ObjectsCompat.equals(porterDuffColorFilter2, this.strokeTintFilter)) ? false : true;
+    }
+
+    private PorterDuffColorFilter calculateTintFilter(ColorStateList colorStateList, PorterDuff.Mode mode, Paint paint, boolean z) {
+        if (colorStateList == null || mode == null) {
+            return calculatePaintColorTintFilter(paint, z);
+        }
+        return calculateTintColorTintFilter(colorStateList, mode, z);
+    }
+
+    private PorterDuffColorFilter calculatePaintColorTintFilter(Paint paint, boolean z) {
+        if (!z) {
+            return null;
+        }
+        int color = paint.getColor();
+        int compositeElevationOverlayIfNeeded = compositeElevationOverlayIfNeeded(color);
+        this.resolvedTintColor = compositeElevationOverlayIfNeeded;
+        if (compositeElevationOverlayIfNeeded != color) {
+            return new PorterDuffColorFilter(compositeElevationOverlayIfNeeded, PorterDuff.Mode.SRC_IN);
+        }
+        return null;
+    }
+
+    private PorterDuffColorFilter calculateTintColorTintFilter(ColorStateList colorStateList, PorterDuff.Mode mode, boolean z) {
+        int colorForState = colorStateList.getColorForState(getState(), 0);
+        if (z) {
+            colorForState = compositeElevationOverlayIfNeeded(colorForState);
+        }
+        this.resolvedTintColor = colorForState;
+        return new PorterDuffColorFilter(colorForState, mode);
+    }
+
+    @Override // android.graphics.drawable.Drawable
+    public boolean isStateful() {
+        return super.isStateful() || (this.drawableState.tintList != null && this.drawableState.tintList.isStateful()) || ((this.drawableState.strokeTintList != null && this.drawableState.strokeTintList.isStateful()) || ((this.drawableState.strokeColor != null && this.drawableState.strokeColor.isStateful()) || (this.drawableState.fillColor != null && this.drawableState.fillColor.isStateful())));
+    }
+
+    @Override // android.graphics.drawable.Drawable, com.google.android.material.internal.TextDrawableHelper.TextDrawableDelegate
+    protected boolean onStateChange(int[] iArr) {
+        boolean z = updateColorsForState(iArr) || updateTintFilter();
+        if (z) {
+            invalidateSelf();
+        }
+        return z;
+    }
+
+    private boolean updateColorsForState(int[] iArr) {
+        boolean z;
+        int color;
+        int colorForState;
+        int color2;
+        int colorForState2;
+        if (this.drawableState.fillColor == null || color2 == (colorForState2 = this.drawableState.fillColor.getColorForState(iArr, (color2 = this.fillPaint.getColor())))) {
+            z = false;
+        } else {
+            this.fillPaint.setColor(colorForState2);
+            z = true;
+        }
+        if (this.drawableState.strokeColor == null || color == (colorForState = this.drawableState.strokeColor.getColorForState(iArr, (color = this.strokePaint.getColor())))) {
+            return z;
+        }
+        this.strokePaint.setColor(colorForState);
+        return true;
+    }
+
+    private float getStrokeInsetLength() {
+        if (hasStroke()) {
+            return this.strokePaint.getStrokeWidth() / 2.0f;
+        }
+        return 0.0f;
+    }
+
+    private RectF getBoundsInsetByStroke() {
+        this.insetRectF.set(getBoundsAsRectF());
+        float strokeInsetLength = getStrokeInsetLength();
+        this.insetRectF.inset(strokeInsetLength, strokeInsetLength);
+        return this.insetRectF;
+    }
+
+    public float getTopLeftCornerResolvedSize() {
+        return this.drawableState.shapeAppearanceModel.getTopLeftCornerSize().getCornerSize(getBoundsAsRectF());
+    }
+
+    public float getTopRightCornerResolvedSize() {
+        return this.drawableState.shapeAppearanceModel.getTopRightCornerSize().getCornerSize(getBoundsAsRectF());
+    }
+
+    public float getBottomLeftCornerResolvedSize() {
+        return this.drawableState.shapeAppearanceModel.getBottomLeftCornerSize().getCornerSize(getBoundsAsRectF());
+    }
+
+    public float getBottomRightCornerResolvedSize() {
+        return this.drawableState.shapeAppearanceModel.getBottomRightCornerSize().getCornerSize(getBoundsAsRectF());
+    }
+
+    public boolean isRoundRect() {
+        return this.drawableState.shapeAppearanceModel.isRoundRect(getBoundsAsRectF());
+    }
+
+    /* JADX INFO: Access modifiers changed from: protected */
+    public static class MaterialShapeDrawableState extends Drawable.ConstantState {
+        int alpha;
+        ColorFilter colorFilter;
+        float elevation;
+        ElevationOverlayProvider elevationOverlayProvider;
+        ColorStateList fillColor;
+        float interpolation;
+        Rect padding;
+        Paint.Style paintStyle;
+        float parentAbsoluteElevation;
+        float scale;
+        int shadowCompatMode;
+        int shadowCompatOffset;
+        int shadowCompatRadius;
+        int shadowCompatRotation;
+        ShapeAppearanceModel shapeAppearanceModel;
+        ColorStateList strokeColor;
+        ColorStateList strokeTintList;
+        float strokeWidth;
+        ColorStateList tintList;
+        PorterDuff.Mode tintMode;
+        float translationZ;
+        boolean useTintColorForShadow;
+
+        @Override // android.graphics.drawable.Drawable.ConstantState
+        public int getChangingConfigurations() {
+            return 0;
+        }
+
+        public MaterialShapeDrawableState(ShapeAppearanceModel shapeAppearanceModel, ElevationOverlayProvider elevationOverlayProvider) {
+            this.fillColor = null;
+            this.strokeColor = null;
+            this.strokeTintList = null;
+            this.tintList = null;
+            this.tintMode = PorterDuff.Mode.SRC_IN;
+            this.padding = null;
+            this.scale = 1.0f;
+            this.interpolation = 1.0f;
+            this.alpha = 255;
+            this.parentAbsoluteElevation = 0.0f;
+            this.elevation = 0.0f;
+            this.translationZ = 0.0f;
+            this.shadowCompatMode = 0;
+            this.shadowCompatRadius = 0;
+            this.shadowCompatOffset = 0;
+            this.shadowCompatRotation = 0;
+            this.useTintColorForShadow = false;
+            this.paintStyle = Paint.Style.FILL_AND_STROKE;
+            this.shapeAppearanceModel = shapeAppearanceModel;
+            this.elevationOverlayProvider = elevationOverlayProvider;
+        }
+
+        public MaterialShapeDrawableState(MaterialShapeDrawableState materialShapeDrawableState) {
+            this.fillColor = null;
+            this.strokeColor = null;
+            this.strokeTintList = null;
+            this.tintList = null;
+            this.tintMode = PorterDuff.Mode.SRC_IN;
+            this.padding = null;
+            this.scale = 1.0f;
+            this.interpolation = 1.0f;
+            this.alpha = 255;
+            this.parentAbsoluteElevation = 0.0f;
+            this.elevation = 0.0f;
+            this.translationZ = 0.0f;
+            this.shadowCompatMode = 0;
+            this.shadowCompatRadius = 0;
+            this.shadowCompatOffset = 0;
+            this.shadowCompatRotation = 0;
+            this.useTintColorForShadow = false;
+            this.paintStyle = Paint.Style.FILL_AND_STROKE;
+            this.shapeAppearanceModel = materialShapeDrawableState.shapeAppearanceModel;
+            this.elevationOverlayProvider = materialShapeDrawableState.elevationOverlayProvider;
+            this.strokeWidth = materialShapeDrawableState.strokeWidth;
+            this.colorFilter = materialShapeDrawableState.colorFilter;
+            this.fillColor = materialShapeDrawableState.fillColor;
+            this.strokeColor = materialShapeDrawableState.strokeColor;
+            this.tintMode = materialShapeDrawableState.tintMode;
+            this.tintList = materialShapeDrawableState.tintList;
+            this.alpha = materialShapeDrawableState.alpha;
+            this.scale = materialShapeDrawableState.scale;
+            this.shadowCompatOffset = materialShapeDrawableState.shadowCompatOffset;
+            this.shadowCompatMode = materialShapeDrawableState.shadowCompatMode;
+            this.useTintColorForShadow = materialShapeDrawableState.useTintColorForShadow;
+            this.interpolation = materialShapeDrawableState.interpolation;
+            this.parentAbsoluteElevation = materialShapeDrawableState.parentAbsoluteElevation;
+            this.elevation = materialShapeDrawableState.elevation;
+            this.translationZ = materialShapeDrawableState.translationZ;
+            this.shadowCompatRadius = materialShapeDrawableState.shadowCompatRadius;
+            this.shadowCompatRotation = materialShapeDrawableState.shadowCompatRotation;
+            this.strokeTintList = materialShapeDrawableState.strokeTintList;
+            this.paintStyle = materialShapeDrawableState.paintStyle;
+            if (materialShapeDrawableState.padding != null) {
+                this.padding = new Rect(materialShapeDrawableState.padding);
+            }
+        }
+
+        @Override // android.graphics.drawable.Drawable.ConstantState
+        public Drawable newDrawable() {
+            MaterialShapeDrawable materialShapeDrawable = new MaterialShapeDrawable(this);
+            materialShapeDrawable.pathDirty = true;
+            return materialShapeDrawable;
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/MaterialShapeUtils.java

@@ -0,0 +1,49 @@
+package com.google.android.material.shape;
+
+import android.graphics.drawable.Drawable;
+import android.view.View;
+import com.google.android.material.internal.ViewUtils;
+
+/* loaded from: classes.dex */
+public class MaterialShapeUtils {
+    private MaterialShapeUtils() {
+    }
+
+    static CornerTreatment createCornerTreatment(int i) {
+        if (i == 0) {
+            return new RoundedCornerTreatment();
+        }
+        if (i == 1) {
+            return new CutCornerTreatment();
+        }
+        return createDefaultCornerTreatment();
+    }
+
+    static CornerTreatment createDefaultCornerTreatment() {
+        return new RoundedCornerTreatment();
+    }
+
+    static EdgeTreatment createDefaultEdgeTreatment() {
+        return new EdgeTreatment();
+    }
+
+    public static void setElevation(View view, float f) {
+        Drawable background = view.getBackground();
+        if (background instanceof MaterialShapeDrawable) {
+            ((MaterialShapeDrawable) background).setElevation(f);
+        }
+    }
+
+    public static void setParentAbsoluteElevation(View view) {
+        Drawable background = view.getBackground();
+        if (background instanceof MaterialShapeDrawable) {
+            setParentAbsoluteElevation(view, (MaterialShapeDrawable) background);
+        }
+    }
+
+    public static void setParentAbsoluteElevation(View view, MaterialShapeDrawable materialShapeDrawable) {
+        if (materialShapeDrawable.isElevationOverlayEnabled()) {
+            materialShapeDrawable.setParentAbsoluteElevation(ViewUtils.getParentAbsoluteElevation(view));
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/OffsetEdgeTreatment.java

@@ -0,0 +1,22 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public final class OffsetEdgeTreatment extends EdgeTreatment {
+    private final float offset;
+    private final EdgeTreatment other;
+
+    public OffsetEdgeTreatment(EdgeTreatment edgeTreatment, float f) {
+        this.other = edgeTreatment;
+        this.offset = f;
+    }
+
+    @Override // com.google.android.material.shape.EdgeTreatment
+    public void getEdgePath(float f, float f2, float f3, ShapePath shapePath) {
+        this.other.getEdgePath(f, f2 - this.offset, f3, shapePath);
+    }
+
+    @Override // com.google.android.material.shape.EdgeTreatment
+    boolean forceIntersection() {
+        return this.other.forceIntersection();
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/RelativeCornerSize.java

@@ -0,0 +1,44 @@
+package com.google.android.material.shape;
+
+import android.graphics.RectF;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public final class RelativeCornerSize implements CornerSize {
+    private final float percent;
+
+    public float getRelativePercent() {
+        return this.percent;
+    }
+
+    public static RelativeCornerSize createFromCornerSize(RectF rectF, CornerSize cornerSize) {
+        if (cornerSize instanceof RelativeCornerSize) {
+            return (RelativeCornerSize) cornerSize;
+        }
+        return new RelativeCornerSize(cornerSize.getCornerSize(rectF) / getMaxCornerSize(rectF));
+    }
+
+    private static float getMaxCornerSize(RectF rectF) {
+        return Math.min(rectF.width(), rectF.height());
+    }
+
+    public RelativeCornerSize(float f) {
+        this.percent = f;
+    }
+
+    @Override // com.google.android.material.shape.CornerSize
+    public float getCornerSize(RectF rectF) {
+        return this.percent * getMaxCornerSize(rectF);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        return (obj instanceof RelativeCornerSize) && this.percent == ((RelativeCornerSize) obj).percent;
+    }
+
+    public int hashCode() {
+        return Arrays.hashCode(new Object[]{Float.valueOf(this.percent)});
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/RoundedCornerTreatment.java

@@ -0,0 +1,22 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public class RoundedCornerTreatment extends CornerTreatment {
+    float radius;
+
+    public RoundedCornerTreatment() {
+        this.radius = -1.0f;
+    }
+
+    @Deprecated
+    public RoundedCornerTreatment(float f) {
+        this.radius = f;
+    }
+
+    @Override // com.google.android.material.shape.CornerTreatment
+    public void getCornerPath(ShapePath shapePath, float f, float f2, float f3) {
+        shapePath.reset(0.0f, f3 * f2, 180.0f, 180.0f - f);
+        float f4 = f3 * 2.0f * f2;
+        shapePath.addArc(0.0f, 0.0f, f4, f4, 180.0f, f);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapeAppearanceModel.java

@@ -0,0 +1,410 @@
+package com.google.android.material.shape;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.RectF;
+import android.util.AttributeSet;
+import android.util.TypedValue;
+import android.view.ContextThemeWrapper;
+import com.google.android.material.R;
+
+/* loaded from: classes.dex */
+public class ShapeAppearanceModel {
+    public static final CornerSize PILL = new RelativeCornerSize(0.5f);
+    EdgeTreatment bottomEdge;
+    CornerTreatment bottomLeftCorner;
+    CornerSize bottomLeftCornerSize;
+    CornerTreatment bottomRightCorner;
+    CornerSize bottomRightCornerSize;
+    EdgeTreatment leftEdge;
+    EdgeTreatment rightEdge;
+    EdgeTreatment topEdge;
+    CornerTreatment topLeftCorner;
+    CornerSize topLeftCornerSize;
+    CornerTreatment topRightCorner;
+    CornerSize topRightCornerSize;
+
+    public interface CornerSizeUnaryOperator {
+        CornerSize apply(CornerSize cornerSize);
+    }
+
+    public EdgeTreatment getBottomEdge() {
+        return this.bottomEdge;
+    }
+
+    public CornerTreatment getBottomLeftCorner() {
+        return this.bottomLeftCorner;
+    }
+
+    public CornerSize getBottomLeftCornerSize() {
+        return this.bottomLeftCornerSize;
+    }
+
+    public CornerTreatment getBottomRightCorner() {
+        return this.bottomRightCorner;
+    }
+
+    public CornerSize getBottomRightCornerSize() {
+        return this.bottomRightCornerSize;
+    }
+
+    public EdgeTreatment getLeftEdge() {
+        return this.leftEdge;
+    }
+
+    public EdgeTreatment getRightEdge() {
+        return this.rightEdge;
+    }
+
+    public EdgeTreatment getTopEdge() {
+        return this.topEdge;
+    }
+
+    public CornerTreatment getTopLeftCorner() {
+        return this.topLeftCorner;
+    }
+
+    public CornerSize getTopLeftCornerSize() {
+        return this.topLeftCornerSize;
+    }
+
+    public CornerTreatment getTopRightCorner() {
+        return this.topRightCorner;
+    }
+
+    public CornerSize getTopRightCornerSize() {
+        return this.topRightCornerSize;
+    }
+
+    public static final class Builder {
+        private EdgeTreatment bottomEdge;
+        private CornerTreatment bottomLeftCorner;
+        private CornerSize bottomLeftCornerSize;
+        private CornerTreatment bottomRightCorner;
+        private CornerSize bottomRightCornerSize;
+        private EdgeTreatment leftEdge;
+        private EdgeTreatment rightEdge;
+        private EdgeTreatment topEdge;
+        private CornerTreatment topLeftCorner;
+        private CornerSize topLeftCornerSize;
+        private CornerTreatment topRightCorner;
+        private CornerSize topRightCornerSize;
+
+        public Builder setBottomEdge(EdgeTreatment edgeTreatment) {
+            this.bottomEdge = edgeTreatment;
+            return this;
+        }
+
+        public Builder setBottomLeftCornerSize(CornerSize cornerSize) {
+            this.bottomLeftCornerSize = cornerSize;
+            return this;
+        }
+
+        public Builder setBottomRightCornerSize(CornerSize cornerSize) {
+            this.bottomRightCornerSize = cornerSize;
+            return this;
+        }
+
+        public Builder setLeftEdge(EdgeTreatment edgeTreatment) {
+            this.leftEdge = edgeTreatment;
+            return this;
+        }
+
+        public Builder setRightEdge(EdgeTreatment edgeTreatment) {
+            this.rightEdge = edgeTreatment;
+            return this;
+        }
+
+        public Builder setTopEdge(EdgeTreatment edgeTreatment) {
+            this.topEdge = edgeTreatment;
+            return this;
+        }
+
+        public Builder setTopLeftCornerSize(CornerSize cornerSize) {
+            this.topLeftCornerSize = cornerSize;
+            return this;
+        }
+
+        public Builder setTopRightCornerSize(CornerSize cornerSize) {
+            this.topRightCornerSize = cornerSize;
+            return this;
+        }
+
+        public Builder() {
+            this.topLeftCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.topRightCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.bottomRightCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.bottomLeftCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.topLeftCornerSize = new AbsoluteCornerSize(0.0f);
+            this.topRightCornerSize = new AbsoluteCornerSize(0.0f);
+            this.bottomRightCornerSize = new AbsoluteCornerSize(0.0f);
+            this.bottomLeftCornerSize = new AbsoluteCornerSize(0.0f);
+            this.topEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.rightEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.bottomEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.leftEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+        }
+
+        public Builder(ShapeAppearanceModel shapeAppearanceModel) {
+            this.topLeftCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.topRightCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.bottomRightCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.bottomLeftCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+            this.topLeftCornerSize = new AbsoluteCornerSize(0.0f);
+            this.topRightCornerSize = new AbsoluteCornerSize(0.0f);
+            this.bottomRightCornerSize = new AbsoluteCornerSize(0.0f);
+            this.bottomLeftCornerSize = new AbsoluteCornerSize(0.0f);
+            this.topEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.rightEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.bottomEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.leftEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+            this.topLeftCorner = shapeAppearanceModel.topLeftCorner;
+            this.topRightCorner = shapeAppearanceModel.topRightCorner;
+            this.bottomRightCorner = shapeAppearanceModel.bottomRightCorner;
+            this.bottomLeftCorner = shapeAppearanceModel.bottomLeftCorner;
+            this.topLeftCornerSize = shapeAppearanceModel.topLeftCornerSize;
+            this.topRightCornerSize = shapeAppearanceModel.topRightCornerSize;
+            this.bottomRightCornerSize = shapeAppearanceModel.bottomRightCornerSize;
+            this.bottomLeftCornerSize = shapeAppearanceModel.bottomLeftCornerSize;
+            this.topEdge = shapeAppearanceModel.topEdge;
+            this.rightEdge = shapeAppearanceModel.rightEdge;
+            this.bottomEdge = shapeAppearanceModel.bottomEdge;
+            this.leftEdge = shapeAppearanceModel.leftEdge;
+        }
+
+        public Builder setAllCorners(int i, float f) {
+            return setAllCorners(MaterialShapeUtils.createCornerTreatment(i)).setAllCornerSizes(f);
+        }
+
+        public Builder setAllCorners(CornerTreatment cornerTreatment) {
+            return setTopLeftCorner(cornerTreatment).setTopRightCorner(cornerTreatment).setBottomRightCorner(cornerTreatment).setBottomLeftCorner(cornerTreatment);
+        }
+
+        public Builder setAllCornerSizes(CornerSize cornerSize) {
+            return setTopLeftCornerSize(cornerSize).setTopRightCornerSize(cornerSize).setBottomRightCornerSize(cornerSize).setBottomLeftCornerSize(cornerSize);
+        }
+
+        public Builder setAllCornerSizes(float f) {
+            return setTopLeftCornerSize(f).setTopRightCornerSize(f).setBottomRightCornerSize(f).setBottomLeftCornerSize(f);
+        }
+
+        public Builder setTopLeftCornerSize(float f) {
+            this.topLeftCornerSize = new AbsoluteCornerSize(f);
+            return this;
+        }
+
+        public Builder setTopRightCornerSize(float f) {
+            this.topRightCornerSize = new AbsoluteCornerSize(f);
+            return this;
+        }
+
+        public Builder setBottomRightCornerSize(float f) {
+            this.bottomRightCornerSize = new AbsoluteCornerSize(f);
+            return this;
+        }
+
+        public Builder setBottomLeftCornerSize(float f) {
+            this.bottomLeftCornerSize = new AbsoluteCornerSize(f);
+            return this;
+        }
+
+        public Builder setTopLeftCorner(int i, float f) {
+            return setTopLeftCorner(MaterialShapeUtils.createCornerTreatment(i)).setTopLeftCornerSize(f);
+        }
+
+        public Builder setTopLeftCorner(int i, CornerSize cornerSize) {
+            return setTopLeftCorner(MaterialShapeUtils.createCornerTreatment(i)).setTopLeftCornerSize(cornerSize);
+        }
+
+        public Builder setTopLeftCorner(CornerTreatment cornerTreatment) {
+            this.topLeftCorner = cornerTreatment;
+            float compatCornerTreatmentSize = compatCornerTreatmentSize(cornerTreatment);
+            if (compatCornerTreatmentSize != -1.0f) {
+                setTopLeftCornerSize(compatCornerTreatmentSize);
+            }
+            return this;
+        }
+
+        public Builder setTopRightCorner(int i, float f) {
+            return setTopRightCorner(MaterialShapeUtils.createCornerTreatment(i)).setTopRightCornerSize(f);
+        }
+
+        public Builder setTopRightCorner(int i, CornerSize cornerSize) {
+            return setTopRightCorner(MaterialShapeUtils.createCornerTreatment(i)).setTopRightCornerSize(cornerSize);
+        }
+
+        public Builder setTopRightCorner(CornerTreatment cornerTreatment) {
+            this.topRightCorner = cornerTreatment;
+            float compatCornerTreatmentSize = compatCornerTreatmentSize(cornerTreatment);
+            if (compatCornerTreatmentSize != -1.0f) {
+                setTopRightCornerSize(compatCornerTreatmentSize);
+            }
+            return this;
+        }
+
+        public Builder setBottomRightCorner(int i, float f) {
+            return setBottomRightCorner(MaterialShapeUtils.createCornerTreatment(i)).setBottomRightCornerSize(f);
+        }
+
+        public Builder setBottomRightCorner(int i, CornerSize cornerSize) {
+            return setBottomRightCorner(MaterialShapeUtils.createCornerTreatment(i)).setBottomRightCornerSize(cornerSize);
+        }
+
+        public Builder setBottomRightCorner(CornerTreatment cornerTreatment) {
+            this.bottomRightCorner = cornerTreatment;
+            float compatCornerTreatmentSize = compatCornerTreatmentSize(cornerTreatment);
+            if (compatCornerTreatmentSize != -1.0f) {
+                setBottomRightCornerSize(compatCornerTreatmentSize);
+            }
+            return this;
+        }
+
+        public Builder setBottomLeftCorner(int i, float f) {
+            return setBottomLeftCorner(MaterialShapeUtils.createCornerTreatment(i)).setBottomLeftCornerSize(f);
+        }
+
+        public Builder setBottomLeftCorner(int i, CornerSize cornerSize) {
+            return setBottomLeftCorner(MaterialShapeUtils.createCornerTreatment(i)).setBottomLeftCornerSize(cornerSize);
+        }
+
+        public Builder setBottomLeftCorner(CornerTreatment cornerTreatment) {
+            this.bottomLeftCorner = cornerTreatment;
+            float compatCornerTreatmentSize = compatCornerTreatmentSize(cornerTreatment);
+            if (compatCornerTreatmentSize != -1.0f) {
+                setBottomLeftCornerSize(compatCornerTreatmentSize);
+            }
+            return this;
+        }
+
+        public Builder setAllEdges(EdgeTreatment edgeTreatment) {
+            return setLeftEdge(edgeTreatment).setTopEdge(edgeTreatment).setRightEdge(edgeTreatment).setBottomEdge(edgeTreatment);
+        }
+
+        private static float compatCornerTreatmentSize(CornerTreatment cornerTreatment) {
+            if (cornerTreatment instanceof RoundedCornerTreatment) {
+                return ((RoundedCornerTreatment) cornerTreatment).radius;
+            }
+            if (cornerTreatment instanceof CutCornerTreatment) {
+                return ((CutCornerTreatment) cornerTreatment).size;
+            }
+            return -1.0f;
+        }
+
+        public ShapeAppearanceModel build() {
+            return new ShapeAppearanceModel(this);
+        }
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static Builder builder(Context context, AttributeSet attributeSet, int i, int i2) {
+        return builder(context, attributeSet, i, i2, 0);
+    }
+
+    public static Builder builder(Context context, AttributeSet attributeSet, int i, int i2, int i3) {
+        return builder(context, attributeSet, i, i2, new AbsoluteCornerSize(i3));
+    }
+
+    public static Builder builder(Context context, AttributeSet attributeSet, int i, int i2, CornerSize cornerSize) {
+        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.MaterialShape, i, i2);
+        int resourceId = obtainStyledAttributes.getResourceId(R.styleable.MaterialShape_shapeAppearance, 0);
+        int resourceId2 = obtainStyledAttributes.getResourceId(R.styleable.MaterialShape_shapeAppearanceOverlay, 0);
+        obtainStyledAttributes.recycle();
+        return builder(context, resourceId, resourceId2, cornerSize);
+    }
+
+    public static Builder builder(Context context, int i, int i2) {
+        return builder(context, i, i2, 0);
+    }
+
+    private static Builder builder(Context context, int i, int i2, int i3) {
+        return builder(context, i, i2, new AbsoluteCornerSize(i3));
+    }
+
+    private static Builder builder(Context context, int i, int i2, CornerSize cornerSize) {
+        ContextThemeWrapper contextThemeWrapper = new ContextThemeWrapper(context, i);
+        if (i2 != 0) {
+            contextThemeWrapper = new ContextThemeWrapper(contextThemeWrapper, i2);
+        }
+        TypedArray obtainStyledAttributes = contextThemeWrapper.obtainStyledAttributes(R.styleable.ShapeAppearance);
+        try {
+            int i3 = obtainStyledAttributes.getInt(R.styleable.ShapeAppearance_cornerFamily, 0);
+            int i4 = obtainStyledAttributes.getInt(R.styleable.ShapeAppearance_cornerFamilyTopLeft, i3);
+            int i5 = obtainStyledAttributes.getInt(R.styleable.ShapeAppearance_cornerFamilyTopRight, i3);
+            int i6 = obtainStyledAttributes.getInt(R.styleable.ShapeAppearance_cornerFamilyBottomRight, i3);
+            int i7 = obtainStyledAttributes.getInt(R.styleable.ShapeAppearance_cornerFamilyBottomLeft, i3);
+            CornerSize cornerSize2 = getCornerSize(obtainStyledAttributes, R.styleable.ShapeAppearance_cornerSize, cornerSize);
+            CornerSize cornerSize3 = getCornerSize(obtainStyledAttributes, R.styleable.ShapeAppearance_cornerSizeTopLeft, cornerSize2);
+            CornerSize cornerSize4 = getCornerSize(obtainStyledAttributes, R.styleable.ShapeAppearance_cornerSizeTopRight, cornerSize2);
+            CornerSize cornerSize5 = getCornerSize(obtainStyledAttributes, R.styleable.ShapeAppearance_cornerSizeBottomRight, cornerSize2);
+            return new Builder().setTopLeftCorner(i4, cornerSize3).setTopRightCorner(i5, cornerSize4).setBottomRightCorner(i6, cornerSize5).setBottomLeftCorner(i7, getCornerSize(obtainStyledAttributes, R.styleable.ShapeAppearance_cornerSizeBottomLeft, cornerSize2));
+        } finally {
+            obtainStyledAttributes.recycle();
+        }
+    }
+
+    private static CornerSize getCornerSize(TypedArray typedArray, int i, CornerSize cornerSize) {
+        TypedValue peekValue = typedArray.peekValue(i);
+        if (peekValue == null) {
+            return cornerSize;
+        }
+        if (peekValue.type == 5) {
+            return new AbsoluteCornerSize(TypedValue.complexToDimensionPixelSize(peekValue.data, typedArray.getResources().getDisplayMetrics()));
+        }
+        return peekValue.type == 6 ? new RelativeCornerSize(peekValue.getFraction(1.0f, 1.0f)) : cornerSize;
+    }
+
+    private ShapeAppearanceModel(Builder builder) {
+        this.topLeftCorner = builder.topLeftCorner;
+        this.topRightCorner = builder.topRightCorner;
+        this.bottomRightCorner = builder.bottomRightCorner;
+        this.bottomLeftCorner = builder.bottomLeftCorner;
+        this.topLeftCornerSize = builder.topLeftCornerSize;
+        this.topRightCornerSize = builder.topRightCornerSize;
+        this.bottomRightCornerSize = builder.bottomRightCornerSize;
+        this.bottomLeftCornerSize = builder.bottomLeftCornerSize;
+        this.topEdge = builder.topEdge;
+        this.rightEdge = builder.rightEdge;
+        this.bottomEdge = builder.bottomEdge;
+        this.leftEdge = builder.leftEdge;
+    }
+
+    public ShapeAppearanceModel() {
+        this.topLeftCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+        this.topRightCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+        this.bottomRightCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+        this.bottomLeftCorner = MaterialShapeUtils.createDefaultCornerTreatment();
+        this.topLeftCornerSize = new AbsoluteCornerSize(0.0f);
+        this.topRightCornerSize = new AbsoluteCornerSize(0.0f);
+        this.bottomRightCornerSize = new AbsoluteCornerSize(0.0f);
+        this.bottomLeftCornerSize = new AbsoluteCornerSize(0.0f);
+        this.topEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+        this.rightEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+        this.bottomEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+        this.leftEdge = MaterialShapeUtils.createDefaultEdgeTreatment();
+    }
+
+    public Builder toBuilder() {
+        return new Builder(this);
+    }
+
+    public ShapeAppearanceModel withCornerSize(float f) {
+        return toBuilder().setAllCornerSizes(f).build();
+    }
+
+    public ShapeAppearanceModel withCornerSize(CornerSize cornerSize) {
+        return toBuilder().setAllCornerSizes(cornerSize).build();
+    }
+
+    public ShapeAppearanceModel withTransformedCornerSizes(CornerSizeUnaryOperator cornerSizeUnaryOperator) {
+        return toBuilder().setTopLeftCornerSize(cornerSizeUnaryOperator.apply(getTopLeftCornerSize())).setTopRightCornerSize(cornerSizeUnaryOperator.apply(getTopRightCornerSize())).setBottomLeftCornerSize(cornerSizeUnaryOperator.apply(getBottomLeftCornerSize())).setBottomRightCornerSize(cornerSizeUnaryOperator.apply(getBottomRightCornerSize())).build();
+    }
+
+    public boolean isRoundRect(RectF rectF) {
+        boolean z = this.leftEdge.getClass().equals(EdgeTreatment.class) && this.rightEdge.getClass().equals(EdgeTreatment.class) && this.topEdge.getClass().equals(EdgeTreatment.class) && this.bottomEdge.getClass().equals(EdgeTreatment.class);
+        float cornerSize = this.topLeftCornerSize.getCornerSize(rectF);
+        return z && ((this.topRightCornerSize.getCornerSize(rectF) > cornerSize ? 1 : (this.topRightCornerSize.getCornerSize(rectF) == cornerSize ? 0 : -1)) == 0 && (this.bottomLeftCornerSize.getCornerSize(rectF) > cornerSize ? 1 : (this.bottomLeftCornerSize.getCornerSize(rectF) == cornerSize ? 0 : -1)) == 0 && (this.bottomRightCornerSize.getCornerSize(rectF) > cornerSize ? 1 : (this.bottomRightCornerSize.getCornerSize(rectF) == cornerSize ? 0 : -1)) == 0) && ((this.topRightCorner instanceof RoundedCornerTreatment) && (this.topLeftCorner instanceof RoundedCornerTreatment) && (this.bottomRightCorner instanceof RoundedCornerTreatment) && (this.bottomLeftCorner instanceof RoundedCornerTreatment));
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapeAppearancePathProvider.java

@@ -0,0 +1,249 @@
+package com.google.android.material.shape;
+
+import android.graphics.Matrix;
+import android.graphics.Path;
+import android.graphics.PointF;
+import android.graphics.RectF;
+
+/* loaded from: classes.dex */
+public class ShapeAppearancePathProvider {
+    private final ShapePath[] cornerPaths = new ShapePath[4];
+    private final Matrix[] cornerTransforms = new Matrix[4];
+    private final Matrix[] edgeTransforms = new Matrix[4];
+    private final PointF pointF = new PointF();
+    private final Path overlappedEdgePath = new Path();
+    private final Path boundsPath = new Path();
+    private final ShapePath shapePath = new ShapePath();
+    private final float[] scratch = new float[2];
+    private final float[] scratch2 = new float[2];
+    private final Path edgePath = new Path();
+    private final Path cornerPath = new Path();
+    private boolean edgeIntersectionCheckEnabled = true;
+
+    public interface PathListener {
+        void onCornerPathCreated(ShapePath shapePath, Matrix matrix, int i);
+
+        void onEdgePathCreated(ShapePath shapePath, Matrix matrix, int i);
+    }
+
+    void setEdgeIntersectionCheckEnable(boolean z) {
+        this.edgeIntersectionCheckEnabled = z;
+    }
+
+    private static class Lazy {
+        static final ShapeAppearancePathProvider INSTANCE = new ShapeAppearancePathProvider();
+
+        private Lazy() {
+        }
+    }
+
+    public ShapeAppearancePathProvider() {
+        for (int i = 0; i < 4; i++) {
+            this.cornerPaths[i] = new ShapePath();
+            this.cornerTransforms[i] = new Matrix();
+            this.edgeTransforms[i] = new Matrix();
+        }
+    }
+
+    public static ShapeAppearancePathProvider getInstance() {
+        return Lazy.INSTANCE;
+    }
+
+    public void calculatePath(ShapeAppearanceModel shapeAppearanceModel, float f, RectF rectF, Path path) {
+        calculatePath(shapeAppearanceModel, f, rectF, null, path);
+    }
+
+    public void calculatePath(ShapeAppearanceModel shapeAppearanceModel, float f, RectF rectF, PathListener pathListener, Path path) {
+        path.rewind();
+        this.overlappedEdgePath.rewind();
+        this.boundsPath.rewind();
+        this.boundsPath.addRect(rectF, Path.Direction.CW);
+        ShapeAppearancePathSpec shapeAppearancePathSpec = new ShapeAppearancePathSpec(shapeAppearanceModel, f, rectF, pathListener, path);
+        for (int i = 0; i < 4; i++) {
+            setCornerPathAndTransform(shapeAppearancePathSpec, i);
+            setEdgePathAndTransform(i);
+        }
+        for (int i2 = 0; i2 < 4; i2++) {
+            appendCornerPath(shapeAppearancePathSpec, i2);
+            appendEdgePath(shapeAppearancePathSpec, i2);
+        }
+        path.close();
+        this.overlappedEdgePath.close();
+        if (this.overlappedEdgePath.isEmpty()) {
+            return;
+        }
+        path.op(this.overlappedEdgePath, Path.Op.UNION);
+    }
+
+    private void setCornerPathAndTransform(ShapeAppearancePathSpec shapeAppearancePathSpec, int i) {
+        getCornerTreatmentForIndex(i, shapeAppearancePathSpec.shapeAppearanceModel).getCornerPath(this.cornerPaths[i], 90.0f, shapeAppearancePathSpec.interpolation, shapeAppearancePathSpec.bounds, getCornerSizeForIndex(i, shapeAppearancePathSpec.shapeAppearanceModel));
+        float angleOfEdge = angleOfEdge(i);
+        this.cornerTransforms[i].reset();
+        getCoordinatesOfCorner(i, shapeAppearancePathSpec.bounds, this.pointF);
+        this.cornerTransforms[i].setTranslate(this.pointF.x, this.pointF.y);
+        this.cornerTransforms[i].preRotate(angleOfEdge);
+    }
+
+    private void setEdgePathAndTransform(int i) {
+        this.scratch[0] = this.cornerPaths[i].getEndX();
+        this.scratch[1] = this.cornerPaths[i].getEndY();
+        this.cornerTransforms[i].mapPoints(this.scratch);
+        float angleOfEdge = angleOfEdge(i);
+        this.edgeTransforms[i].reset();
+        Matrix matrix = this.edgeTransforms[i];
+        float[] fArr = this.scratch;
+        matrix.setTranslate(fArr[0], fArr[1]);
+        this.edgeTransforms[i].preRotate(angleOfEdge);
+    }
+
+    private void appendCornerPath(ShapeAppearancePathSpec shapeAppearancePathSpec, int i) {
+        this.scratch[0] = this.cornerPaths[i].getStartX();
+        this.scratch[1] = this.cornerPaths[i].getStartY();
+        this.cornerTransforms[i].mapPoints(this.scratch);
+        if (i == 0) {
+            Path path = shapeAppearancePathSpec.path;
+            float[] fArr = this.scratch;
+            path.moveTo(fArr[0], fArr[1]);
+        } else {
+            Path path2 = shapeAppearancePathSpec.path;
+            float[] fArr2 = this.scratch;
+            path2.lineTo(fArr2[0], fArr2[1]);
+        }
+        this.cornerPaths[i].applyToPath(this.cornerTransforms[i], shapeAppearancePathSpec.path);
+        if (shapeAppearancePathSpec.pathListener != null) {
+            shapeAppearancePathSpec.pathListener.onCornerPathCreated(this.cornerPaths[i], this.cornerTransforms[i], i);
+        }
+    }
+
+    private void appendEdgePath(ShapeAppearancePathSpec shapeAppearancePathSpec, int i) {
+        int i2 = (i + 1) % 4;
+        this.scratch[0] = this.cornerPaths[i].getEndX();
+        this.scratch[1] = this.cornerPaths[i].getEndY();
+        this.cornerTransforms[i].mapPoints(this.scratch);
+        this.scratch2[0] = this.cornerPaths[i2].getStartX();
+        this.scratch2[1] = this.cornerPaths[i2].getStartY();
+        this.cornerTransforms[i2].mapPoints(this.scratch2);
+        float f = this.scratch[0];
+        float[] fArr = this.scratch2;
+        float max = Math.max(((float) Math.hypot(f - fArr[0], r1[1] - fArr[1])) - 0.001f, 0.0f);
+        float edgeCenterForIndex = getEdgeCenterForIndex(shapeAppearancePathSpec.bounds, i);
+        this.shapePath.reset(0.0f, 0.0f);
+        EdgeTreatment edgeTreatmentForIndex = getEdgeTreatmentForIndex(i, shapeAppearancePathSpec.shapeAppearanceModel);
+        edgeTreatmentForIndex.getEdgePath(max, edgeCenterForIndex, shapeAppearancePathSpec.interpolation, this.shapePath);
+        this.edgePath.reset();
+        this.shapePath.applyToPath(this.edgeTransforms[i], this.edgePath);
+        if (this.edgeIntersectionCheckEnabled && (edgeTreatmentForIndex.forceIntersection() || pathOverlapsCorner(this.edgePath, i) || pathOverlapsCorner(this.edgePath, i2))) {
+            Path path = this.edgePath;
+            path.op(path, this.boundsPath, Path.Op.DIFFERENCE);
+            this.scratch[0] = this.shapePath.getStartX();
+            this.scratch[1] = this.shapePath.getStartY();
+            this.edgeTransforms[i].mapPoints(this.scratch);
+            Path path2 = this.overlappedEdgePath;
+            float[] fArr2 = this.scratch;
+            path2.moveTo(fArr2[0], fArr2[1]);
+            this.shapePath.applyToPath(this.edgeTransforms[i], this.overlappedEdgePath);
+        } else {
+            this.shapePath.applyToPath(this.edgeTransforms[i], shapeAppearancePathSpec.path);
+        }
+        if (shapeAppearancePathSpec.pathListener != null) {
+            shapeAppearancePathSpec.pathListener.onEdgePathCreated(this.shapePath, this.edgeTransforms[i], i);
+        }
+    }
+
+    private boolean pathOverlapsCorner(Path path, int i) {
+        this.cornerPath.reset();
+        this.cornerPaths[i].applyToPath(this.cornerTransforms[i], this.cornerPath);
+        RectF rectF = new RectF();
+        path.computeBounds(rectF, true);
+        this.cornerPath.computeBounds(rectF, true);
+        path.op(this.cornerPath, Path.Op.INTERSECT);
+        path.computeBounds(rectF, true);
+        if (rectF.isEmpty()) {
+            return rectF.width() > 1.0f && rectF.height() > 1.0f;
+        }
+        return true;
+    }
+
+    private float getEdgeCenterForIndex(RectF rectF, int i) {
+        this.scratch[0] = this.cornerPaths[i].endX;
+        this.scratch[1] = this.cornerPaths[i].endY;
+        this.cornerTransforms[i].mapPoints(this.scratch);
+        if (i == 1 || i == 3) {
+            return Math.abs(rectF.centerX() - this.scratch[0]);
+        }
+        return Math.abs(rectF.centerY() - this.scratch[1]);
+    }
+
+    private CornerTreatment getCornerTreatmentForIndex(int i, ShapeAppearanceModel shapeAppearanceModel) {
+        if (i == 1) {
+            return shapeAppearanceModel.getBottomRightCorner();
+        }
+        if (i == 2) {
+            return shapeAppearanceModel.getBottomLeftCorner();
+        }
+        if (i == 3) {
+            return shapeAppearanceModel.getTopLeftCorner();
+        }
+        return shapeAppearanceModel.getTopRightCorner();
+    }
+
+    private CornerSize getCornerSizeForIndex(int i, ShapeAppearanceModel shapeAppearanceModel) {
+        if (i == 1) {
+            return shapeAppearanceModel.getBottomRightCornerSize();
+        }
+        if (i == 2) {
+            return shapeAppearanceModel.getBottomLeftCornerSize();
+        }
+        if (i == 3) {
+            return shapeAppearanceModel.getTopLeftCornerSize();
+        }
+        return shapeAppearanceModel.getTopRightCornerSize();
+    }
+
+    private EdgeTreatment getEdgeTreatmentForIndex(int i, ShapeAppearanceModel shapeAppearanceModel) {
+        if (i == 1) {
+            return shapeAppearanceModel.getBottomEdge();
+        }
+        if (i == 2) {
+            return shapeAppearanceModel.getLeftEdge();
+        }
+        if (i == 3) {
+            return shapeAppearanceModel.getTopEdge();
+        }
+        return shapeAppearanceModel.getRightEdge();
+    }
+
+    private void getCoordinatesOfCorner(int i, RectF rectF, PointF pointF) {
+        if (i == 1) {
+            pointF.set(rectF.right, rectF.bottom);
+            return;
+        }
+        if (i == 2) {
+            pointF.set(rectF.left, rectF.bottom);
+        } else if (i == 3) {
+            pointF.set(rectF.left, rectF.top);
+        } else {
+            pointF.set(rectF.right, rectF.top);
+        }
+    }
+
+    private float angleOfEdge(int i) {
+        return ((i + 1) % 4) * 90;
+    }
+
+    static final class ShapeAppearancePathSpec {
+        public final RectF bounds;
+        public final float interpolation;
+        public final Path path;
+        public final PathListener pathListener;
+        public final ShapeAppearanceModel shapeAppearanceModel;
+
+        ShapeAppearancePathSpec(ShapeAppearanceModel shapeAppearanceModel, float f, RectF rectF, PathListener pathListener, Path path) {
+            this.pathListener = pathListener;
+            this.shapeAppearanceModel = shapeAppearanceModel;
+            this.interpolation = f;
+            this.bounds = rectF;
+            this.path = path;
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapePath.java

@@ -0,0 +1,596 @@
+package com.google.android.material.shape;
+
+import android.graphics.Canvas;
+import android.graphics.Matrix;
+import android.graphics.Path;
+import android.graphics.RectF;
+import com.google.android.material.shadow.ShadowRenderer;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class ShapePath {
+    protected static final float ANGLE_LEFT = 180.0f;
+    private static final float ANGLE_UP = 270.0f;
+    private boolean containsIncompatibleShadowOp;
+
+    @Deprecated
+    public float currentShadowAngle;
+
+    @Deprecated
+    public float endShadowAngle;
+
+    @Deprecated
+    public float endX;
+
+    @Deprecated
+    public float endY;
+    private final List<PathOperation> operations = new ArrayList();
+    private final List<ShadowCompatOperation> shadowCompatOperations = new ArrayList();
+
+    @Deprecated
+    public float startX;
+
+    @Deprecated
+    public float startY;
+
+    public static abstract class PathOperation {
+        protected final Matrix matrix = new Matrix();
+
+        public abstract void applyToPath(Matrix matrix, Path path);
+    }
+
+    private float getCurrentShadowAngle() {
+        return this.currentShadowAngle;
+    }
+
+    private float getEndShadowAngle() {
+        return this.endShadowAngle;
+    }
+
+    private void setCurrentShadowAngle(float f) {
+        this.currentShadowAngle = f;
+    }
+
+    private void setEndShadowAngle(float f) {
+        this.endShadowAngle = f;
+    }
+
+    private void setEndX(float f) {
+        this.endX = f;
+    }
+
+    private void setEndY(float f) {
+        this.endY = f;
+    }
+
+    private void setStartX(float f) {
+        this.startX = f;
+    }
+
+    private void setStartY(float f) {
+        this.startY = f;
+    }
+
+    boolean containsIncompatibleShadowOp() {
+        return this.containsIncompatibleShadowOp;
+    }
+
+    float getEndX() {
+        return this.endX;
+    }
+
+    float getEndY() {
+        return this.endY;
+    }
+
+    float getStartX() {
+        return this.startX;
+    }
+
+    float getStartY() {
+        return this.startY;
+    }
+
+    public ShapePath() {
+        reset(0.0f, 0.0f);
+    }
+
+    public ShapePath(float f, float f2) {
+        reset(f, f2);
+    }
+
+    public void reset(float f, float f2) {
+        reset(f, f2, ANGLE_UP, 0.0f);
+    }
+
+    public void reset(float f, float f2, float f3, float f4) {
+        setStartX(f);
+        setStartY(f2);
+        setEndX(f);
+        setEndY(f2);
+        setCurrentShadowAngle(f3);
+        setEndShadowAngle((f3 + f4) % 360.0f);
+        this.operations.clear();
+        this.shadowCompatOperations.clear();
+        this.containsIncompatibleShadowOp = false;
+    }
+
+    public void lineTo(float f, float f2) {
+        PathLineOperation pathLineOperation = new PathLineOperation();
+        pathLineOperation.x = f;
+        pathLineOperation.y = f2;
+        this.operations.add(pathLineOperation);
+        LineShadowOperation lineShadowOperation = new LineShadowOperation(pathLineOperation, getEndX(), getEndY());
+        addShadowCompatOperation(lineShadowOperation, lineShadowOperation.getAngle() + ANGLE_UP, lineShadowOperation.getAngle() + ANGLE_UP);
+        setEndX(f);
+        setEndY(f2);
+    }
+
+    public void lineTo(float f, float f2, float f3, float f4) {
+        if ((Math.abs(f - getEndX()) < 0.001f && Math.abs(f2 - getEndY()) < 0.001f) || (Math.abs(f - f3) < 0.001f && Math.abs(f2 - f4) < 0.001f)) {
+            lineTo(f3, f4);
+            return;
+        }
+        PathLineOperation pathLineOperation = new PathLineOperation();
+        pathLineOperation.x = f;
+        pathLineOperation.y = f2;
+        this.operations.add(pathLineOperation);
+        PathLineOperation pathLineOperation2 = new PathLineOperation();
+        pathLineOperation2.x = f3;
+        pathLineOperation2.y = f4;
+        this.operations.add(pathLineOperation2);
+        InnerCornerShadowOperation innerCornerShadowOperation = new InnerCornerShadowOperation(pathLineOperation, pathLineOperation2, getEndX(), getEndY());
+        if (innerCornerShadowOperation.getSweepAngle() > 0.0f) {
+            lineTo(f, f2);
+            lineTo(f3, f4);
+        } else {
+            addShadowCompatOperation(innerCornerShadowOperation, innerCornerShadowOperation.getStartAngle() + ANGLE_UP, innerCornerShadowOperation.getEndAngle() + ANGLE_UP);
+            setEndX(f3);
+            setEndY(f4);
+        }
+    }
+
+    public void quadToPoint(float f, float f2, float f3, float f4) {
+        PathQuadOperation pathQuadOperation = new PathQuadOperation();
+        pathQuadOperation.setControlX(f);
+        pathQuadOperation.setControlY(f2);
+        pathQuadOperation.setEndX(f3);
+        pathQuadOperation.setEndY(f4);
+        this.operations.add(pathQuadOperation);
+        this.containsIncompatibleShadowOp = true;
+        setEndX(f3);
+        setEndY(f4);
+    }
+
+    public void cubicToPoint(float f, float f2, float f3, float f4, float f5, float f6) {
+        this.operations.add(new PathCubicOperation(f, f2, f3, f4, f5, f6));
+        this.containsIncompatibleShadowOp = true;
+        setEndX(f5);
+        setEndY(f6);
+    }
+
+    public void addArc(float f, float f2, float f3, float f4, float f5, float f6) {
+        PathArcOperation pathArcOperation = new PathArcOperation(f, f2, f3, f4);
+        pathArcOperation.setStartAngle(f5);
+        pathArcOperation.setSweepAngle(f6);
+        this.operations.add(pathArcOperation);
+        ArcShadowOperation arcShadowOperation = new ArcShadowOperation(pathArcOperation);
+        float f7 = f5 + f6;
+        boolean z = f6 < 0.0f;
+        if (z) {
+            f5 = (f5 + ANGLE_LEFT) % 360.0f;
+        }
+        addShadowCompatOperation(arcShadowOperation, f5, z ? (ANGLE_LEFT + f7) % 360.0f : f7);
+        double d = f7;
+        setEndX(((f + f3) * 0.5f) + (((f3 - f) / 2.0f) * ((float) Math.cos(Math.toRadians(d)))));
+        setEndY(((f2 + f4) * 0.5f) + (((f4 - f2) / 2.0f) * ((float) Math.sin(Math.toRadians(d)))));
+    }
+
+    public void applyToPath(Matrix matrix, Path path) {
+        int size = this.operations.size();
+        for (int i = 0; i < size; i++) {
+            this.operations.get(i).applyToPath(matrix, path);
+        }
+    }
+
+    ShadowCompatOperation createShadowCompatOperation(Matrix matrix) {
+        addConnectingShadowIfNecessary(getEndShadowAngle());
+        final Matrix matrix2 = new Matrix(matrix);
+        final ArrayList arrayList = new ArrayList(this.shadowCompatOperations);
+        return new ShadowCompatOperation() { // from class: com.google.android.material.shape.ShapePath.1
+            @Override // com.google.android.material.shape.ShapePath.ShadowCompatOperation
+            public void draw(Matrix matrix3, ShadowRenderer shadowRenderer, int i, Canvas canvas) {
+                Iterator it = arrayList.iterator();
+                while (it.hasNext()) {
+                    ((ShadowCompatOperation) it.next()).draw(matrix2, shadowRenderer, i, canvas);
+                }
+            }
+        };
+    }
+
+    private void addShadowCompatOperation(ShadowCompatOperation shadowCompatOperation, float f, float f2) {
+        addConnectingShadowIfNecessary(f);
+        this.shadowCompatOperations.add(shadowCompatOperation);
+        setCurrentShadowAngle(f2);
+    }
+
+    private void addConnectingShadowIfNecessary(float f) {
+        if (getCurrentShadowAngle() == f) {
+            return;
+        }
+        float currentShadowAngle = ((f - getCurrentShadowAngle()) + 360.0f) % 360.0f;
+        if (currentShadowAngle > ANGLE_LEFT) {
+            return;
+        }
+        PathArcOperation pathArcOperation = new PathArcOperation(getEndX(), getEndY(), getEndX(), getEndY());
+        pathArcOperation.setStartAngle(getCurrentShadowAngle());
+        pathArcOperation.setSweepAngle(currentShadowAngle);
+        this.shadowCompatOperations.add(new ArcShadowOperation(pathArcOperation));
+        setCurrentShadowAngle(f);
+    }
+
+    static abstract class ShadowCompatOperation {
+        static final Matrix IDENTITY_MATRIX = new Matrix();
+        final Matrix renderMatrix = new Matrix();
+
+        public abstract void draw(Matrix matrix, ShadowRenderer shadowRenderer, int i, Canvas canvas);
+
+        ShadowCompatOperation() {
+        }
+
+        public final void draw(ShadowRenderer shadowRenderer, int i, Canvas canvas) {
+            draw(IDENTITY_MATRIX, shadowRenderer, i, canvas);
+        }
+    }
+
+    static class LineShadowOperation extends ShadowCompatOperation {
+        private final PathLineOperation operation;
+        private final float startX;
+        private final float startY;
+
+        public LineShadowOperation(PathLineOperation pathLineOperation, float f, float f2) {
+            this.operation = pathLineOperation;
+            this.startX = f;
+            this.startY = f2;
+        }
+
+        @Override // com.google.android.material.shape.ShapePath.ShadowCompatOperation
+        public void draw(Matrix matrix, ShadowRenderer shadowRenderer, int i, Canvas canvas) {
+            RectF rectF = new RectF(0.0f, 0.0f, (float) Math.hypot(this.operation.y - this.startY, this.operation.x - this.startX), 0.0f);
+            this.renderMatrix.set(matrix);
+            this.renderMatrix.preTranslate(this.startX, this.startY);
+            this.renderMatrix.preRotate(getAngle());
+            shadowRenderer.drawEdgeShadow(canvas, this.renderMatrix, rectF, i);
+        }
+
+        float getAngle() {
+            return (float) Math.toDegrees(Math.atan((this.operation.y - this.startY) / (this.operation.x - this.startX)));
+        }
+    }
+
+    static class InnerCornerShadowOperation extends ShadowCompatOperation {
+        private final PathLineOperation operation1;
+        private final PathLineOperation operation2;
+        private final float startX;
+        private final float startY;
+
+        public InnerCornerShadowOperation(PathLineOperation pathLineOperation, PathLineOperation pathLineOperation2, float f, float f2) {
+            this.operation1 = pathLineOperation;
+            this.operation2 = pathLineOperation2;
+            this.startX = f;
+            this.startY = f2;
+        }
+
+        @Override // com.google.android.material.shape.ShapePath.ShadowCompatOperation
+        public void draw(Matrix matrix, ShadowRenderer shadowRenderer, int i, Canvas canvas) {
+            ShadowRenderer shadowRenderer2;
+            float sweepAngle = getSweepAngle();
+            if (sweepAngle > 0.0f) {
+                return;
+            }
+            double hypot = Math.hypot(this.operation1.x - this.startX, this.operation1.y - this.startY);
+            double hypot2 = Math.hypot(this.operation2.x - this.operation1.x, this.operation2.y - this.operation1.y);
+            float min = (float) Math.min(i, Math.min(hypot, hypot2));
+            double d = min;
+            double tan = Math.tan(Math.toRadians((-sweepAngle) / 2.0f)) * d;
+            if (hypot > tan) {
+                RectF rectF = new RectF(0.0f, 0.0f, (float) (hypot - tan), 0.0f);
+                this.renderMatrix.set(matrix);
+                this.renderMatrix.preTranslate(this.startX, this.startY);
+                this.renderMatrix.preRotate(getStartAngle());
+                shadowRenderer2 = shadowRenderer;
+                shadowRenderer2.drawEdgeShadow(canvas, this.renderMatrix, rectF, i);
+            } else {
+                shadowRenderer2 = shadowRenderer;
+            }
+            float f = 2.0f * min;
+            RectF rectF2 = new RectF(0.0f, 0.0f, f, f);
+            this.renderMatrix.set(matrix);
+            this.renderMatrix.preTranslate(this.operation1.x, this.operation1.y);
+            this.renderMatrix.preRotate(getStartAngle());
+            this.renderMatrix.preTranslate((float) ((-tan) - d), (-2.0f) * min);
+            shadowRenderer.drawInnerCornerShadow(canvas, this.renderMatrix, rectF2, (int) min, 450.0f, sweepAngle, new float[]{(float) (d + tan), f});
+            if (hypot2 > tan) {
+                RectF rectF3 = new RectF(0.0f, 0.0f, (float) (hypot2 - tan), 0.0f);
+                this.renderMatrix.set(matrix);
+                this.renderMatrix.preTranslate(this.operation1.x, this.operation1.y);
+                this.renderMatrix.preRotate(getEndAngle());
+                this.renderMatrix.preTranslate((float) tan, 0.0f);
+                shadowRenderer2.drawEdgeShadow(canvas, this.renderMatrix, rectF3, i);
+            }
+        }
+
+        float getStartAngle() {
+            return (float) Math.toDegrees(Math.atan((this.operation1.y - this.startY) / (this.operation1.x - this.startX)));
+        }
+
+        float getEndAngle() {
+            return (float) Math.toDegrees(Math.atan((this.operation2.y - this.operation1.y) / (this.operation2.x - this.operation1.x)));
+        }
+
+        float getSweepAngle() {
+            float endAngle = ((getEndAngle() - getStartAngle()) + 360.0f) % 360.0f;
+            return endAngle <= ShapePath.ANGLE_LEFT ? endAngle : endAngle - 360.0f;
+        }
+    }
+
+    static class ArcShadowOperation extends ShadowCompatOperation {
+        private final PathArcOperation operation;
+
+        public ArcShadowOperation(PathArcOperation pathArcOperation) {
+            this.operation = pathArcOperation;
+        }
+
+        @Override // com.google.android.material.shape.ShapePath.ShadowCompatOperation
+        public void draw(Matrix matrix, ShadowRenderer shadowRenderer, int i, Canvas canvas) {
+            shadowRenderer.drawCornerShadow(canvas, matrix, new RectF(this.operation.getLeft(), this.operation.getTop(), this.operation.getRight(), this.operation.getBottom()), i, this.operation.getStartAngle(), this.operation.getSweepAngle());
+        }
+    }
+
+    public static class PathLineOperation extends PathOperation {
+        private float x;
+        private float y;
+
+        @Override // com.google.android.material.shape.ShapePath.PathOperation
+        public void applyToPath(Matrix matrix, Path path) {
+            Matrix matrix2 = this.matrix;
+            matrix.invert(matrix2);
+            path.transform(matrix2);
+            path.lineTo(this.x, this.y);
+            path.transform(matrix);
+        }
+    }
+
+    public static class PathQuadOperation extends PathOperation {
+
+        @Deprecated
+        public float controlX;
+
+        @Deprecated
+        public float controlY;
+
+        @Deprecated
+        public float endX;
+
+        @Deprecated
+        public float endY;
+
+        private float getControlX() {
+            return this.controlX;
+        }
+
+        private float getControlY() {
+            return this.controlY;
+        }
+
+        private float getEndX() {
+            return this.endX;
+        }
+
+        private float getEndY() {
+            return this.endY;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void setControlX(float f) {
+            this.controlX = f;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void setControlY(float f) {
+            this.controlY = f;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void setEndX(float f) {
+            this.endX = f;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void setEndY(float f) {
+            this.endY = f;
+        }
+
+        @Override // com.google.android.material.shape.ShapePath.PathOperation
+        public void applyToPath(Matrix matrix, Path path) {
+            Matrix matrix2 = this.matrix;
+            matrix.invert(matrix2);
+            path.transform(matrix2);
+            path.quadTo(getControlX(), getControlY(), getEndX(), getEndY());
+            path.transform(matrix);
+        }
+    }
+
+    public static class PathArcOperation extends PathOperation {
+        private static final RectF rectF = new RectF();
+
+        @Deprecated
+        public float bottom;
+
+        @Deprecated
+        public float left;
+
+        @Deprecated
+        public float right;
+
+        @Deprecated
+        public float startAngle;
+
+        @Deprecated
+        public float sweepAngle;
+
+        @Deprecated
+        public float top;
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public float getBottom() {
+            return this.bottom;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public float getLeft() {
+            return this.left;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public float getRight() {
+            return this.right;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public float getStartAngle() {
+            return this.startAngle;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public float getSweepAngle() {
+            return this.sweepAngle;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public float getTop() {
+            return this.top;
+        }
+
+        private void setBottom(float f) {
+            this.bottom = f;
+        }
+
+        private void setLeft(float f) {
+            this.left = f;
+        }
+
+        private void setRight(float f) {
+            this.right = f;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void setStartAngle(float f) {
+            this.startAngle = f;
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void setSweepAngle(float f) {
+            this.sweepAngle = f;
+        }
+
+        private void setTop(float f) {
+            this.top = f;
+        }
+
+        public PathArcOperation(float f, float f2, float f3, float f4) {
+            setLeft(f);
+            setTop(f2);
+            setRight(f3);
+            setBottom(f4);
+        }
+
+        @Override // com.google.android.material.shape.ShapePath.PathOperation
+        public void applyToPath(Matrix matrix, Path path) {
+            Matrix matrix2 = this.matrix;
+            matrix.invert(matrix2);
+            path.transform(matrix2);
+            RectF rectF2 = rectF;
+            rectF2.set(getLeft(), getTop(), getRight(), getBottom());
+            path.arcTo(rectF2, getStartAngle(), getSweepAngle(), false);
+            path.transform(matrix);
+        }
+    }
+
+    public static class PathCubicOperation extends PathOperation {
+        private float controlX1;
+        private float controlX2;
+        private float controlY1;
+        private float controlY2;
+        private float endX;
+        private float endY;
+
+        private float getControlX1() {
+            return this.controlX1;
+        }
+
+        private float getControlX2() {
+            return this.controlX2;
+        }
+
+        private float getControlY1() {
+            return this.controlY1;
+        }
+
+        private float getControlY2() {
+            return this.controlY1;
+        }
+
+        private float getEndX() {
+            return this.endX;
+        }
+
+        private float getEndY() {
+            return this.endY;
+        }
+
+        private void setControlX1(float f) {
+            this.controlX1 = f;
+        }
+
+        private void setControlX2(float f) {
+            this.controlX2 = f;
+        }
+
+        private void setControlY1(float f) {
+            this.controlY1 = f;
+        }
+
+        private void setControlY2(float f) {
+            this.controlY2 = f;
+        }
+
+        private void setEndX(float f) {
+            this.endX = f;
+        }
+
+        private void setEndY(float f) {
+            this.endY = f;
+        }
+
+        public PathCubicOperation(float f, float f2, float f3, float f4, float f5, float f6) {
+            setControlX1(f);
+            setControlY1(f2);
+            setControlX2(f3);
+            setControlY2(f4);
+            setEndX(f5);
+            setEndY(f6);
+        }
+
+        @Override // com.google.android.material.shape.ShapePath.PathOperation
+        public void applyToPath(Matrix matrix, Path path) {
+            Matrix matrix2 = this.matrix;
+            matrix.invert(matrix2);
+            path.transform(matrix2);
+            path.cubicTo(this.controlX1, this.controlY1, this.controlX2, this.controlY2, this.endX, this.endY);
+            path.transform(matrix);
+        }
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapePathModel.java

@@ -0,0 +1,77 @@
+package com.google.android.material.shape;
+
+@Deprecated
+/* loaded from: classes.dex */
+public class ShapePathModel extends ShapeAppearanceModel {
+    @Deprecated
+    public void setAllCorners(CornerTreatment cornerTreatment) {
+        this.topLeftCorner = cornerTreatment;
+        this.topRightCorner = cornerTreatment;
+        this.bottomRightCorner = cornerTreatment;
+        this.bottomLeftCorner = cornerTreatment;
+    }
+
+    @Deprecated
+    public void setAllEdges(EdgeTreatment edgeTreatment) {
+        this.leftEdge = edgeTreatment;
+        this.topEdge = edgeTreatment;
+        this.rightEdge = edgeTreatment;
+        this.bottomEdge = edgeTreatment;
+    }
+
+    @Deprecated
+    public void setCornerTreatments(CornerTreatment cornerTreatment, CornerTreatment cornerTreatment2, CornerTreatment cornerTreatment3, CornerTreatment cornerTreatment4) {
+        this.topLeftCorner = cornerTreatment;
+        this.topRightCorner = cornerTreatment2;
+        this.bottomRightCorner = cornerTreatment3;
+        this.bottomLeftCorner = cornerTreatment4;
+    }
+
+    @Deprecated
+    public void setEdgeTreatments(EdgeTreatment edgeTreatment, EdgeTreatment edgeTreatment2, EdgeTreatment edgeTreatment3, EdgeTreatment edgeTreatment4) {
+        this.leftEdge = edgeTreatment;
+        this.topEdge = edgeTreatment2;
+        this.rightEdge = edgeTreatment3;
+        this.bottomEdge = edgeTreatment4;
+    }
+
+    @Deprecated
+    public void setTopLeftCorner(CornerTreatment cornerTreatment) {
+        this.topLeftCorner = cornerTreatment;
+    }
+
+    @Deprecated
+    public void setTopRightCorner(CornerTreatment cornerTreatment) {
+        this.topRightCorner = cornerTreatment;
+    }
+
+    @Deprecated
+    public void setBottomRightCorner(CornerTreatment cornerTreatment) {
+        this.bottomRightCorner = cornerTreatment;
+    }
+
+    @Deprecated
+    public void setBottomLeftCorner(CornerTreatment cornerTreatment) {
+        this.bottomLeftCorner = cornerTreatment;
+    }
+
+    @Deprecated
+    public void setTopEdge(EdgeTreatment edgeTreatment) {
+        this.topEdge = edgeTreatment;
+    }
+
+    @Deprecated
+    public void setRightEdge(EdgeTreatment edgeTreatment) {
+        this.rightEdge = edgeTreatment;
+    }
+
+    @Deprecated
+    public void setBottomEdge(EdgeTreatment edgeTreatment) {
+        this.bottomEdge = edgeTreatment;
+    }
+
+    @Deprecated
+    public void setLeftEdge(EdgeTreatment edgeTreatment) {
+        this.leftEdge = edgeTreatment;
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/Shapeable.java

@@ -0,0 +1,8 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public interface Shapeable {
+    ShapeAppearanceModel getShapeAppearanceModel();
+
+    void setShapeAppearanceModel(ShapeAppearanceModel shapeAppearanceModel);
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapeableDelegate.java

@@ -0,0 +1,81 @@
+package com.google.android.material.shape;
+
+import android.graphics.Canvas;
+import android.graphics.Path;
+import android.graphics.RectF;
+import android.os.Build;
+import android.view.View;
+import com.google.android.material.canvas.CanvasCompat;
+
+/* loaded from: classes.dex */
+public abstract class ShapeableDelegate {
+    ShapeAppearanceModel shapeAppearanceModel;
+    boolean forceCompatClippingEnabled = false;
+    boolean offsetZeroCornerEdgeBoundsEnabled = false;
+    RectF maskBounds = new RectF();
+    final Path shapePath = new Path();
+
+    abstract void invalidateClippingMethod(View view);
+
+    public boolean isForceCompatClippingEnabled() {
+        return this.forceCompatClippingEnabled;
+    }
+
+    abstract boolean shouldUseCompatClipping();
+
+    public static ShapeableDelegate create(View view) {
+        if (Build.VERSION.SDK_INT >= 33) {
+            return new ShapeableDelegateV33(view);
+        }
+        if (Build.VERSION.SDK_INT >= 22) {
+            return new ShapeableDelegateV22(view);
+        }
+        return new ShapeableDelegateV14();
+    }
+
+    public void setForceCompatClippingEnabled(View view, boolean z) {
+        if (z != this.forceCompatClippingEnabled) {
+            this.forceCompatClippingEnabled = z;
+            invalidateClippingMethod(view);
+        }
+    }
+
+    public void setOffsetZeroCornerEdgeBoundsEnabled(View view, boolean z) {
+        this.offsetZeroCornerEdgeBoundsEnabled = z;
+        invalidateClippingMethod(view);
+    }
+
+    public void onShapeAppearanceChanged(View view, ShapeAppearanceModel shapeAppearanceModel) {
+        this.shapeAppearanceModel = shapeAppearanceModel;
+        updateShapePath();
+        invalidateClippingMethod(view);
+    }
+
+    public void onMaskChanged(View view, RectF rectF) {
+        this.maskBounds = rectF;
+        updateShapePath();
+        invalidateClippingMethod(view);
+    }
+
+    private void updateShapePath() {
+        if (!isMaskBoundsValid() || this.shapeAppearanceModel == null) {
+            return;
+        }
+        ShapeAppearancePathProvider.getInstance().calculatePath(this.shapeAppearanceModel, 1.0f, this.maskBounds, this.shapePath);
+    }
+
+    private boolean isMaskBoundsValid() {
+        return this.maskBounds.left <= this.maskBounds.right && this.maskBounds.top <= this.maskBounds.bottom;
+    }
+
+    public void maybeClip(Canvas canvas, CanvasCompat.CanvasOperation canvasOperation) {
+        if (shouldUseCompatClipping() && !this.shapePath.isEmpty()) {
+            canvas.save();
+            canvas.clipPath(this.shapePath);
+            canvasOperation.run(canvas);
+            canvas.restore();
+            return;
+        }
+        canvasOperation.run(canvas);
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapeableDelegateV14.java

@@ -0,0 +1,22 @@
+package com.google.android.material.shape;
+
+import android.view.View;
+
+/* loaded from: classes.dex */
+class ShapeableDelegateV14 extends ShapeableDelegate {
+    @Override // com.google.android.material.shape.ShapeableDelegate
+    boolean shouldUseCompatClipping() {
+        return true;
+    }
+
+    ShapeableDelegateV14() {
+    }
+
+    @Override // com.google.android.material.shape.ShapeableDelegate
+    void invalidateClippingMethod(View view) {
+        if (this.shapeAppearanceModel == null || this.maskBounds.isEmpty() || !shouldUseCompatClipping()) {
+            return;
+        }
+        view.invalidate();
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapeableDelegateV22.java

@@ -0,0 +1,96 @@
+package com.google.android.material.shape;
+
+import android.graphics.Outline;
+import android.view.View;
+import android.view.ViewOutlineProvider;
+
+/* loaded from: classes.dex */
+class ShapeableDelegateV22 extends ShapeableDelegate {
+    private boolean canUseViewOutline = false;
+    private float cornerRadius = 0.0f;
+
+    float getCornerRadius() {
+        return this.cornerRadius;
+    }
+
+    ShapeableDelegateV22(View view) {
+        initMaskOutlineProvider(view);
+    }
+
+    @Override // com.google.android.material.shape.ShapeableDelegate
+    boolean shouldUseCompatClipping() {
+        return !this.canUseViewOutline || this.forceCompatClippingEnabled;
+    }
+
+    @Override // com.google.android.material.shape.ShapeableDelegate
+    void invalidateClippingMethod(View view) {
+        this.cornerRadius = getDefaultCornerRadius();
+        this.canUseViewOutline = isShapeRoundRect() || offsetZeroCornerEdgeBoundsIfPossible();
+        view.setClipToOutline(!shouldUseCompatClipping());
+        if (shouldUseCompatClipping()) {
+            view.invalidate();
+        } else {
+            view.invalidateOutline();
+        }
+    }
+
+    private float getDefaultCornerRadius() {
+        if (this.shapeAppearanceModel == null || this.maskBounds == null) {
+            return 0.0f;
+        }
+        return this.shapeAppearanceModel.topRightCornerSize.getCornerSize(this.maskBounds);
+    }
+
+    private boolean isShapeRoundRect() {
+        if (this.maskBounds.isEmpty() || this.shapeAppearanceModel == null) {
+            return false;
+        }
+        return this.shapeAppearanceModel.isRoundRect(this.maskBounds);
+    }
+
+    private boolean offsetZeroCornerEdgeBoundsIfPossible() {
+        if (!this.maskBounds.isEmpty() && this.shapeAppearanceModel != null && this.offsetZeroCornerEdgeBoundsEnabled && !this.shapeAppearanceModel.isRoundRect(this.maskBounds) && shapeUsesAllRoundedCornerTreatments(this.shapeAppearanceModel)) {
+            float cornerSize = this.shapeAppearanceModel.getTopLeftCornerSize().getCornerSize(this.maskBounds);
+            float cornerSize2 = this.shapeAppearanceModel.getTopRightCornerSize().getCornerSize(this.maskBounds);
+            float cornerSize3 = this.shapeAppearanceModel.getBottomLeftCornerSize().getCornerSize(this.maskBounds);
+            float cornerSize4 = this.shapeAppearanceModel.getBottomRightCornerSize().getCornerSize(this.maskBounds);
+            if (cornerSize == 0.0f && cornerSize3 == 0.0f && cornerSize2 == cornerSize4) {
+                this.maskBounds.set(this.maskBounds.left - cornerSize2, this.maskBounds.top, this.maskBounds.right, this.maskBounds.bottom);
+                this.cornerRadius = cornerSize2;
+                return true;
+            }
+            if (cornerSize == 0.0f && cornerSize2 == 0.0f && cornerSize3 == cornerSize4) {
+                this.maskBounds.set(this.maskBounds.left, this.maskBounds.top - cornerSize3, this.maskBounds.right, this.maskBounds.bottom);
+                this.cornerRadius = cornerSize3;
+                return true;
+            }
+            if (cornerSize2 == 0.0f && cornerSize4 == 0.0f && cornerSize == cornerSize3) {
+                this.maskBounds.set(this.maskBounds.left, this.maskBounds.top, this.maskBounds.right + cornerSize, this.maskBounds.bottom);
+                this.cornerRadius = cornerSize;
+                return true;
+            }
+            if (cornerSize3 == 0.0f && cornerSize4 == 0.0f && cornerSize == cornerSize2) {
+                this.maskBounds.set(this.maskBounds.left, this.maskBounds.top, this.maskBounds.right, this.maskBounds.bottom + cornerSize);
+                this.cornerRadius = cornerSize;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean shapeUsesAllRoundedCornerTreatments(ShapeAppearanceModel shapeAppearanceModel) {
+        return (shapeAppearanceModel.getTopLeftCorner() instanceof RoundedCornerTreatment) && (shapeAppearanceModel.getTopRightCorner() instanceof RoundedCornerTreatment) && (shapeAppearanceModel.getBottomLeftCorner() instanceof RoundedCornerTreatment) && (shapeAppearanceModel.getBottomRightCorner() instanceof RoundedCornerTreatment);
+    }
+
+    private void initMaskOutlineProvider(View view) {
+        view.setOutlineProvider(new ViewOutlineProvider() { // from class: com.google.android.material.shape.ShapeableDelegateV22.1
+            @Override // android.view.ViewOutlineProvider
+            public void getOutline(View view2, Outline outline) {
+                if (ShapeableDelegateV22.this.shapeAppearanceModel == null || ShapeableDelegateV22.this.maskBounds.isEmpty()) {
+                    return;
+                }
+                outline.setRoundRect((int) ShapeableDelegateV22.this.maskBounds.left, (int) ShapeableDelegateV22.this.maskBounds.top, (int) ShapeableDelegateV22.this.maskBounds.right, (int) ShapeableDelegateV22.this.maskBounds.bottom, ShapeableDelegateV22.this.cornerRadius);
+            }
+        });
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/ShapeableDelegateV33.java

@@ -0,0 +1,39 @@
+package com.google.android.material.shape;
+
+import android.graphics.Outline;
+import android.view.View;
+import android.view.ViewOutlineProvider;
+
+/* loaded from: classes.dex */
+class ShapeableDelegateV33 extends ShapeableDelegate {
+    ShapeableDelegateV33(View view) {
+        initMaskOutlineProvider(view);
+    }
+
+    @Override // com.google.android.material.shape.ShapeableDelegate
+    boolean shouldUseCompatClipping() {
+        return this.forceCompatClippingEnabled;
+    }
+
+    @Override // com.google.android.material.shape.ShapeableDelegate
+    void invalidateClippingMethod(View view) {
+        view.setClipToOutline(!shouldUseCompatClipping());
+        if (shouldUseCompatClipping()) {
+            view.invalidate();
+        } else {
+            view.invalidateOutline();
+        }
+    }
+
+    private void initMaskOutlineProvider(View view) {
+        view.setOutlineProvider(new ViewOutlineProvider() { // from class: com.google.android.material.shape.ShapeableDelegateV33.1
+            @Override // android.view.ViewOutlineProvider
+            public void getOutline(View view2, Outline outline) {
+                if (ShapeableDelegateV33.this.shapePath.isEmpty()) {
+                    return;
+                }
+                outline.setPath(ShapeableDelegateV33.this.shapePath);
+            }
+        });
+    }
+}

02-Easy5/E5/sources/com/google/android/material/shape/TriangleEdgeTreatment.java

@@ -0,0 +1,26 @@
+package com.google.android.material.shape;
+
+/* loaded from: classes.dex */
+public class TriangleEdgeTreatment extends EdgeTreatment {
+    private final boolean inside;
+    private final float size;
+
+    public TriangleEdgeTreatment(float f, boolean z) {
+        this.size = f;
+        this.inside = z;
+    }
+
+    @Override // com.google.android.material.shape.EdgeTreatment
+    public void getEdgePath(float f, float f2, float f3, ShapePath shapePath) {
+        if (this.inside) {
+            shapePath.lineTo(f2 - (this.size * f3), 0.0f);
+            float f4 = this.size;
+            shapePath.lineTo(f2, f4 * f3, (f4 * f3) + f2, 0.0f);
+            shapePath.lineTo(f, 0.0f);
+            return;
+        }
+        float f5 = this.size;
+        shapePath.lineTo(f2 - (f5 * f3), 0.0f, f2, (-f5) * f3);
+        shapePath.lineTo(f2 + (this.size * f3), 0.0f, f, 0.0f);
+    }
+}