package androidx.vectordrawable.graphics.drawable; import android.content.res.ColorStateList; import android.content.res.Resources; import android.content.res.TypedArray; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.ColorFilter; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.Path; import android.graphics.PathMeasure; import android.graphics.PorterDuff; import android.graphics.PorterDuffColorFilter; import android.graphics.Rect; import android.graphics.Region; import android.graphics.Shader; import android.graphics.drawable.Drawable; import android.graphics.drawable.VectorDrawable; import android.util.AttributeSet; import android.util.Log; import androidx.annotation.ColorInt; import androidx.annotation.DrawableRes; import androidx.annotation.NonNull; import androidx.annotation.Nullable; import androidx.annotation.RequiresApi; import androidx.annotation.RestrictTo; import androidx.collection.ArrayMap; import androidx.core.content.res.ComplexColorCompat; import androidx.core.content.res.ResourcesCompat; import androidx.core.content.res.TypedArrayUtils; import androidx.core.graphics.PathParser; import androidx.core.graphics.drawable.DrawableCompat; import androidx.core.view.ViewCompat; import java.io.IOException; import java.util.ArrayDeque; import java.util.ArrayList; import okhttp3.HttpUrl; import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; /* JADX INFO: loaded from: classes.dex */ public class VectorDrawableCompat extends VectorDrawableCommon { private static final boolean DBG_VECTOR_DRAWABLE = false; static final PorterDuff.Mode DEFAULT_TINT_MODE = PorterDuff.Mode.SRC_IN; private static final int LINECAP_BUTT = 0; private static final int LINECAP_ROUND = 1; private static final int LINECAP_SQUARE = 2; private static final int LINEJOIN_BEVEL = 2; private static final int LINEJOIN_MITER = 0; private static final int LINEJOIN_ROUND = 1; static final String LOGTAG = "VectorDrawableCompat"; private static final int MAX_CACHED_BITMAP_SIZE = 2048; private static final String SHAPE_CLIP_PATH = "clip-path"; private static final String SHAPE_GROUP = "group"; private static final String SHAPE_PATH = "path"; private static final String SHAPE_VECTOR = "vector"; private boolean mAllowCaching; private Drawable.ConstantState mCachedConstantStateDelegate; private ColorFilter mColorFilter; private boolean mMutated; private PorterDuffColorFilter mTintFilter; private final Rect mTmpBounds; private final float[] mTmpFloats; private final Matrix mTmpMatrix; private VectorDrawableCompatState mVectorState; private static class VClipPath extends VPath { VClipPath() { } private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser) { String string = typedArray.getString(0); if (string != null) { this.mPathName = string; } String string2 = typedArray.getString(1); if (string2 != null) { this.mNodes = PathParser.createNodesFromPathData(string2); } this.mFillRule = TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "fillType", 2, 0); } public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) { if (TypedArrayUtils.hasAttribute(xmlPullParser, "pathData")) { TypedArray typedArrayObtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_CLIP_PATH); updateStateFromTypedArray(typedArrayObtainAttributes, xmlPullParser); typedArrayObtainAttributes.recycle(); } } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VPath public boolean isClipPath() { return true; } VClipPath(VClipPath vClipPath) { super(vClipPath); } } private static abstract class VObject { private VObject() { } public boolean isStateful() { return false; } public boolean onStateChanged(int[] iArr) { return false; } } private static class VectorDrawableCompatState extends Drawable.ConstantState { boolean mAutoMirrored; boolean mCacheDirty; boolean mCachedAutoMirrored; Bitmap mCachedBitmap; int mCachedRootAlpha; int[] mCachedThemeAttrs; ColorStateList mCachedTint; PorterDuff.Mode mCachedTintMode; int mChangingConfigurations; Paint mTempPaint; ColorStateList mTint; PorterDuff.Mode mTintMode; VPathRenderer mVPathRenderer; public VectorDrawableCompatState(VectorDrawableCompatState vectorDrawableCompatState) { this.mTint = null; this.mTintMode = VectorDrawableCompat.DEFAULT_TINT_MODE; if (vectorDrawableCompatState != null) { this.mChangingConfigurations = vectorDrawableCompatState.mChangingConfigurations; VPathRenderer vPathRenderer = new VPathRenderer(vectorDrawableCompatState.mVPathRenderer); this.mVPathRenderer = vPathRenderer; if (vectorDrawableCompatState.mVPathRenderer.mFillPaint != null) { vPathRenderer.mFillPaint = new Paint(vectorDrawableCompatState.mVPathRenderer.mFillPaint); } if (vectorDrawableCompatState.mVPathRenderer.mStrokePaint != null) { this.mVPathRenderer.mStrokePaint = new Paint(vectorDrawableCompatState.mVPathRenderer.mStrokePaint); } this.mTint = vectorDrawableCompatState.mTint; this.mTintMode = vectorDrawableCompatState.mTintMode; this.mAutoMirrored = vectorDrawableCompatState.mAutoMirrored; } } public boolean canReuseBitmap(int i2, int i3) { return i2 == this.mCachedBitmap.getWidth() && i3 == this.mCachedBitmap.getHeight(); } public boolean canReuseCache() { return !this.mCacheDirty && this.mCachedTint == this.mTint && this.mCachedTintMode == this.mTintMode && this.mCachedAutoMirrored == this.mAutoMirrored && this.mCachedRootAlpha == this.mVPathRenderer.getRootAlpha(); } public void createCachedBitmapIfNeeded(int i2, int i3) { if (this.mCachedBitmap == null || !canReuseBitmap(i2, i3)) { this.mCachedBitmap = Bitmap.createBitmap(i2, i3, Bitmap.Config.ARGB_8888); this.mCacheDirty = true; } } public void drawCachedBitmapWithRootAlpha(Canvas canvas, ColorFilter colorFilter, Rect rect) { canvas.drawBitmap(this.mCachedBitmap, (Rect) null, rect, getPaint(colorFilter)); } @Override // android.graphics.drawable.Drawable.ConstantState public int getChangingConfigurations() { return this.mChangingConfigurations; } public Paint getPaint(ColorFilter colorFilter) { if (!hasTranslucentRoot() && colorFilter == null) { return null; } if (this.mTempPaint == null) { Paint paint = new Paint(); this.mTempPaint = paint; paint.setFilterBitmap(true); } this.mTempPaint.setAlpha(this.mVPathRenderer.getRootAlpha()); this.mTempPaint.setColorFilter(colorFilter); return this.mTempPaint; } public boolean hasTranslucentRoot() { return this.mVPathRenderer.getRootAlpha() < 255; } public boolean isStateful() { return this.mVPathRenderer.isStateful(); } @Override // android.graphics.drawable.Drawable.ConstantState @NonNull public Drawable newDrawable() { return new VectorDrawableCompat(this); } public boolean onStateChanged(int[] iArr) { boolean zOnStateChanged = this.mVPathRenderer.onStateChanged(iArr); this.mCacheDirty |= zOnStateChanged; return zOnStateChanged; } public void updateCacheStates() { this.mCachedTint = this.mTint; this.mCachedTintMode = this.mTintMode; this.mCachedRootAlpha = this.mVPathRenderer.getRootAlpha(); this.mCachedAutoMirrored = this.mAutoMirrored; this.mCacheDirty = false; } public void updateCachedBitmap(int i2, int i3) { this.mCachedBitmap.eraseColor(0); this.mVPathRenderer.draw(new Canvas(this.mCachedBitmap), i2, i3, null); } @Override // android.graphics.drawable.Drawable.ConstantState @NonNull public Drawable newDrawable(Resources resources) { return new VectorDrawableCompat(this); } public VectorDrawableCompatState() { this.mTint = null; this.mTintMode = VectorDrawableCompat.DEFAULT_TINT_MODE; this.mVPathRenderer = new VPathRenderer(); } } VectorDrawableCompat() { this.mAllowCaching = true; this.mTmpFloats = new float[9]; this.mTmpMatrix = new Matrix(); this.mTmpBounds = new Rect(); this.mVectorState = new VectorDrawableCompatState(); } static int applyAlpha(int i2, float f2) { return (i2 & ViewCompat.MEASURED_SIZE_MASK) | (((int) (Color.alpha(i2) * f2)) << 24); } @Nullable public static VectorDrawableCompat create(@NonNull Resources resources, @DrawableRes int i2, @Nullable Resources.Theme theme) { VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat(); vectorDrawableCompat.mDelegateDrawable = ResourcesCompat.getDrawable(resources, i2, theme); vectorDrawableCompat.mCachedConstantStateDelegate = new VectorDrawableDelegateState(vectorDrawableCompat.mDelegateDrawable.getConstantState()); return vectorDrawableCompat; } public static VectorDrawableCompat createFromXmlInner(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException { VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat(); vectorDrawableCompat.inflate(resources, xmlPullParser, attributeSet, theme); return vectorDrawableCompat; } private void inflateInternal(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException { VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; VPathRenderer vPathRenderer = vectorDrawableCompatState.mVPathRenderer; ArrayDeque arrayDeque = new ArrayDeque(); arrayDeque.push(vPathRenderer.mRootGroup); int eventType = xmlPullParser.getEventType(); int depth = xmlPullParser.getDepth() + 1; boolean z2 = true; while (eventType != 1 && (xmlPullParser.getDepth() >= depth || eventType != 3)) { if (eventType == 2) { String name = xmlPullParser.getName(); VGroup vGroup = (VGroup) arrayDeque.peek(); if (SHAPE_PATH.equals(name)) { VFullPath vFullPath = new VFullPath(); vFullPath.inflate(resources, attributeSet, theme, xmlPullParser); vGroup.mChildren.add(vFullPath); if (vFullPath.getPathName() != null) { vPathRenderer.mVGTargetsMap.put(vFullPath.getPathName(), vFullPath); } vectorDrawableCompatState.mChangingConfigurations = vFullPath.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations; z2 = false; } else if (SHAPE_CLIP_PATH.equals(name)) { VClipPath vClipPath = new VClipPath(); vClipPath.inflate(resources, attributeSet, theme, xmlPullParser); vGroup.mChildren.add(vClipPath); if (vClipPath.getPathName() != null) { vPathRenderer.mVGTargetsMap.put(vClipPath.getPathName(), vClipPath); } vectorDrawableCompatState.mChangingConfigurations = vClipPath.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations; } else if (SHAPE_GROUP.equals(name)) { VGroup vGroup2 = new VGroup(); vGroup2.inflate(resources, attributeSet, theme, xmlPullParser); vGroup.mChildren.add(vGroup2); arrayDeque.push(vGroup2); if (vGroup2.getGroupName() != null) { vPathRenderer.mVGTargetsMap.put(vGroup2.getGroupName(), vGroup2); } vectorDrawableCompatState.mChangingConfigurations = vGroup2.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations; } } else if (eventType == 3 && SHAPE_GROUP.equals(xmlPullParser.getName())) { arrayDeque.pop(); } eventType = xmlPullParser.next(); } if (z2) { throw new XmlPullParserException("no path defined"); } } private boolean needMirroring() { return isAutoMirrored() && DrawableCompat.getLayoutDirection(this) == 1; } private static PorterDuff.Mode parseTintModeCompat(int i2, PorterDuff.Mode mode) { if (i2 == 3) { return PorterDuff.Mode.SRC_OVER; } if (i2 == 5) { return PorterDuff.Mode.SRC_IN; } if (i2 == 9) { return PorterDuff.Mode.SRC_ATOP; } switch (i2) { case 14: return PorterDuff.Mode.MULTIPLY; case 15: return PorterDuff.Mode.SCREEN; case 16: return PorterDuff.Mode.ADD; default: return mode; } } private void printGroupTree(VGroup vGroup, int i2) { String str = HttpUrl.FRAGMENT_ENCODE_SET; for (int i3 = 0; i3 < i2; i3++) { str = str + " "; } Log.v(LOGTAG, str + "current group is :" + vGroup.getGroupName() + " rotation is " + vGroup.mRotate); StringBuilder sb = new StringBuilder(); sb.append(str); sb.append("matrix is :"); sb.append(vGroup.getLocalMatrix().toString()); Log.v(LOGTAG, sb.toString()); for (int i4 = 0; i4 < vGroup.mChildren.size(); i4++) { VObject vObject = vGroup.mChildren.get(i4); if (vObject instanceof VGroup) { printGroupTree((VGroup) vObject, i2 + 1); } else { ((VPath) vObject).printVPath(i2 + 1); } } } private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser, Resources.Theme theme) throws XmlPullParserException { VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; VPathRenderer vPathRenderer = vectorDrawableCompatState.mVPathRenderer; vectorDrawableCompatState.mTintMode = parseTintModeCompat(TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "tintMode", 6, -1), PorterDuff.Mode.SRC_IN); ColorStateList namedColorStateList = TypedArrayUtils.getNamedColorStateList(typedArray, xmlPullParser, theme, "tint", 1); if (namedColorStateList != null) { vectorDrawableCompatState.mTint = namedColorStateList; } vectorDrawableCompatState.mAutoMirrored = TypedArrayUtils.getNamedBoolean(typedArray, xmlPullParser, "autoMirrored", 5, vectorDrawableCompatState.mAutoMirrored); vPathRenderer.mViewportWidth = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "viewportWidth", 7, vPathRenderer.mViewportWidth); float namedFloat = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "viewportHeight", 8, vPathRenderer.mViewportHeight); vPathRenderer.mViewportHeight = namedFloat; if (vPathRenderer.mViewportWidth <= 0.0f) { throw new XmlPullParserException(typedArray.getPositionDescription() + " tag requires viewportWidth > 0"); } if (namedFloat <= 0.0f) { throw new XmlPullParserException(typedArray.getPositionDescription() + " tag requires viewportHeight > 0"); } vPathRenderer.mBaseWidth = typedArray.getDimension(3, vPathRenderer.mBaseWidth); float dimension = typedArray.getDimension(2, vPathRenderer.mBaseHeight); vPathRenderer.mBaseHeight = dimension; if (vPathRenderer.mBaseWidth <= 0.0f) { throw new XmlPullParserException(typedArray.getPositionDescription() + " tag requires width > 0"); } if (dimension <= 0.0f) { throw new XmlPullParserException(typedArray.getPositionDescription() + " tag requires height > 0"); } vPathRenderer.setAlpha(TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "alpha", 4, vPathRenderer.getAlpha())); String string = typedArray.getString(0); if (string != null) { vPathRenderer.mRootName = string; vPathRenderer.mVGTargetsMap.put(string, vPathRenderer); } } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void applyTheme(Resources.Theme theme) { super.applyTheme(theme); } @Override // android.graphics.drawable.Drawable public boolean canApplyTheme() { Drawable drawable = this.mDelegateDrawable; if (drawable == null) { return false; } DrawableCompat.canApplyTheme(drawable); return false; } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void clearColorFilter() { super.clearColorFilter(); } @Override // android.graphics.drawable.Drawable public void draw(Canvas canvas) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.draw(canvas); return; } copyBounds(this.mTmpBounds); if (this.mTmpBounds.width() <= 0 || this.mTmpBounds.height() <= 0) { return; } ColorFilter colorFilter = this.mColorFilter; if (colorFilter == null) { colorFilter = this.mTintFilter; } canvas.getMatrix(this.mTmpMatrix); this.mTmpMatrix.getValues(this.mTmpFloats); float fAbs = Math.abs(this.mTmpFloats[0]); float fAbs2 = Math.abs(this.mTmpFloats[4]); float fAbs3 = Math.abs(this.mTmpFloats[1]); float fAbs4 = Math.abs(this.mTmpFloats[3]); if (fAbs3 != 0.0f || fAbs4 != 0.0f) { fAbs = 1.0f; fAbs2 = 1.0f; } int iMin = Math.min(2048, (int) (this.mTmpBounds.width() * fAbs)); int iMin2 = Math.min(2048, (int) (this.mTmpBounds.height() * fAbs2)); if (iMin <= 0 || iMin2 <= 0) { return; } int iSave = canvas.save(); Rect rect = this.mTmpBounds; canvas.translate(rect.left, rect.top); if (needMirroring()) { canvas.translate(this.mTmpBounds.width(), 0.0f); canvas.scale(-1.0f, 1.0f); } this.mTmpBounds.offsetTo(0, 0); this.mVectorState.createCachedBitmapIfNeeded(iMin, iMin2); if (!this.mAllowCaching) { this.mVectorState.updateCachedBitmap(iMin, iMin2); } else if (!this.mVectorState.canReuseCache()) { this.mVectorState.updateCachedBitmap(iMin, iMin2); this.mVectorState.updateCacheStates(); } this.mVectorState.drawCachedBitmapWithRootAlpha(canvas, colorFilter, this.mTmpBounds); canvas.restoreToCount(iSave); } @Override // android.graphics.drawable.Drawable public int getAlpha() { Drawable drawable = this.mDelegateDrawable; return drawable != null ? DrawableCompat.getAlpha(drawable) : this.mVectorState.mVPathRenderer.getRootAlpha(); } @Override // android.graphics.drawable.Drawable public int getChangingConfigurations() { Drawable drawable = this.mDelegateDrawable; return drawable != null ? drawable.getChangingConfigurations() : super.getChangingConfigurations() | this.mVectorState.getChangingConfigurations(); } @Override // android.graphics.drawable.Drawable public ColorFilter getColorFilter() { Drawable drawable = this.mDelegateDrawable; return drawable != null ? DrawableCompat.getColorFilter(drawable) : this.mColorFilter; } @Override // android.graphics.drawable.Drawable public Drawable.ConstantState getConstantState() { if (this.mDelegateDrawable != null) { return new VectorDrawableDelegateState(this.mDelegateDrawable.getConstantState()); } this.mVectorState.mChangingConfigurations = getChangingConfigurations(); return this.mVectorState; } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ Drawable getCurrent() { return super.getCurrent(); } @Override // android.graphics.drawable.Drawable public int getIntrinsicHeight() { Drawable drawable = this.mDelegateDrawable; return drawable != null ? drawable.getIntrinsicHeight() : (int) this.mVectorState.mVPathRenderer.mBaseHeight; } @Override // android.graphics.drawable.Drawable public int getIntrinsicWidth() { Drawable drawable = this.mDelegateDrawable; return drawable != null ? drawable.getIntrinsicWidth() : (int) this.mVectorState.mVPathRenderer.mBaseWidth; } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ int getMinimumHeight() { return super.getMinimumHeight(); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ int getMinimumWidth() { return super.getMinimumWidth(); } @Override // android.graphics.drawable.Drawable public int getOpacity() { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { return drawable.getOpacity(); } return -3; } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ boolean getPadding(Rect rect) { return super.getPadding(rect); } @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX}) public float getPixelSize() { VPathRenderer vPathRenderer; VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; if (vectorDrawableCompatState == null || (vPathRenderer = vectorDrawableCompatState.mVPathRenderer) == null) { return 1.0f; } float f2 = vPathRenderer.mBaseWidth; if (f2 == 0.0f) { return 1.0f; } float f3 = vPathRenderer.mBaseHeight; if (f3 == 0.0f) { return 1.0f; } float f4 = vPathRenderer.mViewportHeight; if (f4 == 0.0f) { return 1.0f; } float f5 = vPathRenderer.mViewportWidth; if (f5 == 0.0f) { return 1.0f; } return Math.min(f5 / f2, f4 / f3); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ int[] getState() { return super.getState(); } Object getTargetByName(String str) { return this.mVectorState.mVPathRenderer.mVGTargetsMap.get(str); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ Region getTransparentRegion() { return super.getTransparentRegion(); } @Override // android.graphics.drawable.Drawable public void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet) throws XmlPullParserException, IOException { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.inflate(resources, xmlPullParser, attributeSet); } else { inflate(resources, xmlPullParser, attributeSet, null); } } @Override // android.graphics.drawable.Drawable public void invalidateSelf() { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.invalidateSelf(); } else { super.invalidateSelf(); } } @Override // android.graphics.drawable.Drawable public boolean isAutoMirrored() { Drawable drawable = this.mDelegateDrawable; return drawable != null ? DrawableCompat.isAutoMirrored(drawable) : this.mVectorState.mAutoMirrored; } @Override // android.graphics.drawable.Drawable public boolean isStateful() { VectorDrawableCompatState vectorDrawableCompatState; ColorStateList colorStateList; Drawable drawable = this.mDelegateDrawable; return drawable != null ? drawable.isStateful() : super.isStateful() || ((vectorDrawableCompatState = this.mVectorState) != null && (vectorDrawableCompatState.isStateful() || ((colorStateList = this.mVectorState.mTint) != null && colorStateList.isStateful()))); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void jumpToCurrentState() { super.jumpToCurrentState(); } @Override // android.graphics.drawable.Drawable public Drawable mutate() { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.mutate(); return this; } if (!this.mMutated && super.mutate() == this) { this.mVectorState = new VectorDrawableCompatState(this.mVectorState); this.mMutated = true; } return this; } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable protected void onBoundsChange(Rect rect) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.setBounds(rect); } } @Override // android.graphics.drawable.Drawable protected boolean onStateChange(int[] iArr) { boolean z2; PorterDuff.Mode mode; Drawable drawable = this.mDelegateDrawable; if (drawable != null) { return drawable.setState(iArr); } VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; ColorStateList colorStateList = vectorDrawableCompatState.mTint; if (colorStateList == null || (mode = vectorDrawableCompatState.mTintMode) == null) { z2 = false; } else { this.mTintFilter = updateTintFilter(this.mTintFilter, colorStateList, mode); invalidateSelf(); z2 = true; } if (!vectorDrawableCompatState.isStateful() || !vectorDrawableCompatState.onStateChanged(iArr)) { return z2; } invalidateSelf(); return true; } @Override // android.graphics.drawable.Drawable public void scheduleSelf(Runnable runnable, long j2) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.scheduleSelf(runnable, j2); } else { super.scheduleSelf(runnable, j2); } } void setAllowCaching(boolean z2) { this.mAllowCaching = z2; } @Override // android.graphics.drawable.Drawable public void setAlpha(int i2) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.setAlpha(i2); } else if (this.mVectorState.mVPathRenderer.getRootAlpha() != i2) { this.mVectorState.mVPathRenderer.setRootAlpha(i2); invalidateSelf(); } } @Override // android.graphics.drawable.Drawable public void setAutoMirrored(boolean z2) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { DrawableCompat.setAutoMirrored(drawable, z2); } else { this.mVectorState.mAutoMirrored = z2; } } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void setChangingConfigurations(int i2) { super.setChangingConfigurations(i2); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void setColorFilter(int i2, PorterDuff.Mode mode) { super.setColorFilter(i2, mode); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void setFilterBitmap(boolean z2) { super.setFilterBitmap(z2); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void setHotspot(float f2, float f3) { super.setHotspot(f2, f3); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ void setHotspotBounds(int i2, int i3, int i4, int i5) { super.setHotspotBounds(i2, i3, i4, i5); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable public /* bridge */ /* synthetic */ boolean setState(int[] iArr) { return super.setState(iArr); } @Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable public void setTint(int i2) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { DrawableCompat.setTint(drawable, i2); } else { setTintList(ColorStateList.valueOf(i2)); } } @Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable public void setTintList(ColorStateList colorStateList) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { DrawableCompat.setTintList(drawable, colorStateList); return; } VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; if (vectorDrawableCompatState.mTint != colorStateList) { vectorDrawableCompatState.mTint = colorStateList; this.mTintFilter = updateTintFilter(this.mTintFilter, colorStateList, vectorDrawableCompatState.mTintMode); invalidateSelf(); } } @Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable public void setTintMode(PorterDuff.Mode mode) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { DrawableCompat.setTintMode(drawable, mode); return; } VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; if (vectorDrawableCompatState.mTintMode != mode) { vectorDrawableCompatState.mTintMode = mode; this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, mode); invalidateSelf(); } } @Override // android.graphics.drawable.Drawable public boolean setVisible(boolean z2, boolean z3) { Drawable drawable = this.mDelegateDrawable; return drawable != null ? drawable.setVisible(z2, z3) : super.setVisible(z2, z3); } @Override // android.graphics.drawable.Drawable public void unscheduleSelf(Runnable runnable) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.unscheduleSelf(runnable); } else { super.unscheduleSelf(runnable); } } PorterDuffColorFilter updateTintFilter(PorterDuffColorFilter porterDuffColorFilter, ColorStateList colorStateList, PorterDuff.Mode mode) { if (colorStateList == null || mode == null) { return null; } return new PorterDuffColorFilter(colorStateList.getColorForState(getState(), 0), mode); } @RequiresApi(24) private static class VectorDrawableDelegateState extends Drawable.ConstantState { private final Drawable.ConstantState mDelegateState; public VectorDrawableDelegateState(Drawable.ConstantState constantState) { this.mDelegateState = constantState; } @Override // android.graphics.drawable.Drawable.ConstantState public boolean canApplyTheme() { return this.mDelegateState.canApplyTheme(); } @Override // android.graphics.drawable.Drawable.ConstantState public int getChangingConfigurations() { return this.mDelegateState.getChangingConfigurations(); } @Override // android.graphics.drawable.Drawable.ConstantState public Drawable newDrawable() { VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat(); vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(); return vectorDrawableCompat; } @Override // android.graphics.drawable.Drawable.ConstantState public Drawable newDrawable(Resources resources) { VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat(); vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(resources); return vectorDrawableCompat; } @Override // android.graphics.drawable.Drawable.ConstantState public Drawable newDrawable(Resources resources, Resources.Theme theme) { VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat(); vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(resources, theme); return vectorDrawableCompat; } } @Override // android.graphics.drawable.Drawable public void setColorFilter(ColorFilter colorFilter) { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { drawable.setColorFilter(colorFilter); } else { this.mColorFilter = colorFilter; invalidateSelf(); } } private static abstract class VPath extends VObject { protected static final int FILL_TYPE_WINDING = 0; int mChangingConfigurations; int mFillRule; protected PathParser.PathDataNode[] mNodes; String mPathName; public VPath() { super(); this.mNodes = null; this.mFillRule = 0; } public void applyTheme(Resources.Theme theme) { } public boolean canApplyTheme() { return false; } public PathParser.PathDataNode[] getPathData() { return this.mNodes; } public String getPathName() { return this.mPathName; } public boolean isClipPath() { return false; } public String nodesToString(PathParser.PathDataNode[] pathDataNodeArr) { String str = " "; for (int i2 = 0; i2 < pathDataNodeArr.length; i2++) { str = str + pathDataNodeArr[i2].mType + ":"; for (float f2 : pathDataNodeArr[i2].mParams) { str = str + f2 + ","; } } return str; } public void printVPath(int i2) { String str = HttpUrl.FRAGMENT_ENCODE_SET; for (int i3 = 0; i3 < i2; i3++) { str = str + " "; } Log.v(VectorDrawableCompat.LOGTAG, str + "current path is :" + this.mPathName + " pathData is " + nodesToString(this.mNodes)); } public void setPathData(PathParser.PathDataNode[] pathDataNodeArr) { if (PathParser.canMorph(this.mNodes, pathDataNodeArr)) { PathParser.updateNodes(this.mNodes, pathDataNodeArr); } else { this.mNodes = PathParser.deepCopyNodes(pathDataNodeArr); } } public void toPath(Path path) { path.reset(); PathParser.PathDataNode[] pathDataNodeArr = this.mNodes; if (pathDataNodeArr != null) { PathParser.PathDataNode.nodesToPath(pathDataNodeArr, path); } } public VPath(VPath vPath) { super(); this.mNodes = null; this.mFillRule = 0; this.mPathName = vPath.mPathName; this.mChangingConfigurations = vPath.mChangingConfigurations; this.mNodes = PathParser.deepCopyNodes(vPath.mNodes); } } @Override // android.graphics.drawable.Drawable public void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException { Drawable drawable = this.mDelegateDrawable; if (drawable != null) { DrawableCompat.inflate(drawable, resources, xmlPullParser, attributeSet, theme); return; } VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState; vectorDrawableCompatState.mVPathRenderer = new VPathRenderer(); TypedArray typedArrayObtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_TYPE_ARRAY); updateStateFromTypedArray(typedArrayObtainAttributes, xmlPullParser, theme); typedArrayObtainAttributes.recycle(); vectorDrawableCompatState.mChangingConfigurations = getChangingConfigurations(); vectorDrawableCompatState.mCacheDirty = true; inflateInternal(resources, xmlPullParser, attributeSet, theme); this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, vectorDrawableCompatState.mTintMode); } VectorDrawableCompat(@NonNull VectorDrawableCompatState vectorDrawableCompatState) { this.mAllowCaching = true; this.mTmpFloats = new float[9]; this.mTmpMatrix = new Matrix(); this.mTmpBounds = new Rect(); this.mVectorState = vectorDrawableCompatState; this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, vectorDrawableCompatState.mTintMode); } private static class VFullPath extends VPath { float mFillAlpha; ComplexColorCompat mFillColor; float mStrokeAlpha; ComplexColorCompat mStrokeColor; Paint.Cap mStrokeLineCap; Paint.Join mStrokeLineJoin; float mStrokeMiterlimit; float mStrokeWidth; private int[] mThemeAttrs; float mTrimPathEnd; float mTrimPathOffset; float mTrimPathStart; VFullPath() { this.mStrokeWidth = 0.0f; this.mStrokeAlpha = 1.0f; this.mFillAlpha = 1.0f; this.mTrimPathStart = 0.0f; this.mTrimPathEnd = 1.0f; this.mTrimPathOffset = 0.0f; this.mStrokeLineCap = Paint.Cap.BUTT; this.mStrokeLineJoin = Paint.Join.MITER; this.mStrokeMiterlimit = 4.0f; } private Paint.Cap getStrokeLineCap(int i2, Paint.Cap cap) { return i2 != 0 ? i2 != 1 ? i2 != 2 ? cap : Paint.Cap.SQUARE : Paint.Cap.ROUND : Paint.Cap.BUTT; } private Paint.Join getStrokeLineJoin(int i2, Paint.Join join) { return i2 != 0 ? i2 != 1 ? i2 != 2 ? join : Paint.Join.BEVEL : Paint.Join.ROUND : Paint.Join.MITER; } private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser, Resources.Theme theme) { this.mThemeAttrs = null; if (TypedArrayUtils.hasAttribute(xmlPullParser, "pathData")) { String string = typedArray.getString(0); if (string != null) { this.mPathName = string; } String string2 = typedArray.getString(2); if (string2 != null) { this.mNodes = PathParser.createNodesFromPathData(string2); } this.mFillColor = TypedArrayUtils.getNamedComplexColor(typedArray, xmlPullParser, theme, "fillColor", 1, 0); this.mFillAlpha = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "fillAlpha", 12, this.mFillAlpha); this.mStrokeLineCap = getStrokeLineCap(TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "strokeLineCap", 8, -1), this.mStrokeLineCap); this.mStrokeLineJoin = getStrokeLineJoin(TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "strokeLineJoin", 9, -1), this.mStrokeLineJoin); this.mStrokeMiterlimit = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "strokeMiterLimit", 10, this.mStrokeMiterlimit); this.mStrokeColor = TypedArrayUtils.getNamedComplexColor(typedArray, xmlPullParser, theme, "strokeColor", 3, 0); this.mStrokeAlpha = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "strokeAlpha", 11, this.mStrokeAlpha); this.mStrokeWidth = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "strokeWidth", 4, this.mStrokeWidth); this.mTrimPathEnd = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "trimPathEnd", 6, this.mTrimPathEnd); this.mTrimPathOffset = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "trimPathOffset", 7, this.mTrimPathOffset); this.mTrimPathStart = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "trimPathStart", 5, this.mTrimPathStart); this.mFillRule = TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "fillType", 13, this.mFillRule); } } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VPath public void applyTheme(Resources.Theme theme) { } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VPath public boolean canApplyTheme() { return this.mThemeAttrs != null; } float getFillAlpha() { return this.mFillAlpha; } @ColorInt int getFillColor() { return this.mFillColor.getColor(); } float getStrokeAlpha() { return this.mStrokeAlpha; } @ColorInt int getStrokeColor() { return this.mStrokeColor.getColor(); } float getStrokeWidth() { return this.mStrokeWidth; } float getTrimPathEnd() { return this.mTrimPathEnd; } float getTrimPathOffset() { return this.mTrimPathOffset; } float getTrimPathStart() { return this.mTrimPathStart; } public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) { TypedArray typedArrayObtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_PATH); updateStateFromTypedArray(typedArrayObtainAttributes, xmlPullParser, theme); typedArrayObtainAttributes.recycle(); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject public boolean isStateful() { return this.mFillColor.isStateful() || this.mStrokeColor.isStateful(); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject public boolean onStateChanged(int[] iArr) { return this.mStrokeColor.onStateChanged(iArr) | this.mFillColor.onStateChanged(iArr); } void setFillAlpha(float f2) { this.mFillAlpha = f2; } void setFillColor(int i2) { this.mFillColor.setColor(i2); } void setStrokeAlpha(float f2) { this.mStrokeAlpha = f2; } void setStrokeColor(int i2) { this.mStrokeColor.setColor(i2); } void setStrokeWidth(float f2) { this.mStrokeWidth = f2; } void setTrimPathEnd(float f2) { this.mTrimPathEnd = f2; } void setTrimPathOffset(float f2) { this.mTrimPathOffset = f2; } void setTrimPathStart(float f2) { this.mTrimPathStart = f2; } VFullPath(VFullPath vFullPath) { super(vFullPath); this.mStrokeWidth = 0.0f; this.mStrokeAlpha = 1.0f; this.mFillAlpha = 1.0f; this.mTrimPathStart = 0.0f; this.mTrimPathEnd = 1.0f; this.mTrimPathOffset = 0.0f; this.mStrokeLineCap = Paint.Cap.BUTT; this.mStrokeLineJoin = Paint.Join.MITER; this.mStrokeMiterlimit = 4.0f; this.mThemeAttrs = vFullPath.mThemeAttrs; this.mStrokeColor = vFullPath.mStrokeColor; this.mStrokeWidth = vFullPath.mStrokeWidth; this.mStrokeAlpha = vFullPath.mStrokeAlpha; this.mFillColor = vFullPath.mFillColor; this.mFillRule = vFullPath.mFillRule; this.mFillAlpha = vFullPath.mFillAlpha; this.mTrimPathStart = vFullPath.mTrimPathStart; this.mTrimPathEnd = vFullPath.mTrimPathEnd; this.mTrimPathOffset = vFullPath.mTrimPathOffset; this.mStrokeLineCap = vFullPath.mStrokeLineCap; this.mStrokeLineJoin = vFullPath.mStrokeLineJoin; this.mStrokeMiterlimit = vFullPath.mStrokeMiterlimit; } } private static class VPathRenderer { private static final Matrix IDENTITY_MATRIX = new Matrix(); float mBaseHeight; float mBaseWidth; private int mChangingConfigurations; Paint mFillPaint; private final Matrix mFinalPathMatrix; Boolean mIsStateful; private final Path mPath; private PathMeasure mPathMeasure; private final Path mRenderPath; int mRootAlpha; final VGroup mRootGroup; String mRootName; Paint mStrokePaint; final ArrayMap mVGTargetsMap; float mViewportHeight; float mViewportWidth; public VPathRenderer() { this.mFinalPathMatrix = new Matrix(); this.mBaseWidth = 0.0f; this.mBaseHeight = 0.0f; this.mViewportWidth = 0.0f; this.mViewportHeight = 0.0f; this.mRootAlpha = 255; this.mRootName = null; this.mIsStateful = null; this.mVGTargetsMap = new ArrayMap<>(); this.mRootGroup = new VGroup(); this.mPath = new Path(); this.mRenderPath = new Path(); } private static float cross(float f2, float f3, float f4, float f5) { return (f2 * f5) - (f3 * f4); } private void drawGroupTree(VGroup vGroup, Matrix matrix, Canvas canvas, int i2, int i3, ColorFilter colorFilter) { vGroup.mStackedMatrix.set(matrix); vGroup.mStackedMatrix.preConcat(vGroup.mLocalMatrix); canvas.save(); for (int i4 = 0; i4 < vGroup.mChildren.size(); i4++) { VObject vObject = vGroup.mChildren.get(i4); if (vObject instanceof VGroup) { drawGroupTree((VGroup) vObject, vGroup.mStackedMatrix, canvas, i2, i3, colorFilter); } else if (vObject instanceof VPath) { drawPath(vGroup, (VPath) vObject, canvas, i2, i3, colorFilter); } } canvas.restore(); } private void drawPath(VGroup vGroup, VPath vPath, Canvas canvas, int i2, int i3, ColorFilter colorFilter) { float f2 = i2 / this.mViewportWidth; float f3 = i3 / this.mViewportHeight; float fMin = Math.min(f2, f3); Matrix matrix = vGroup.mStackedMatrix; this.mFinalPathMatrix.set(matrix); this.mFinalPathMatrix.postScale(f2, f3); float matrixScale = getMatrixScale(matrix); if (matrixScale == 0.0f) { return; } vPath.toPath(this.mPath); Path path = this.mPath; this.mRenderPath.reset(); if (vPath.isClipPath()) { this.mRenderPath.setFillType(vPath.mFillRule == 0 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD); this.mRenderPath.addPath(path, this.mFinalPathMatrix); canvas.clipPath(this.mRenderPath); return; } VFullPath vFullPath = (VFullPath) vPath; float f4 = vFullPath.mTrimPathStart; if (f4 != 0.0f || vFullPath.mTrimPathEnd != 1.0f) { float f5 = vFullPath.mTrimPathOffset; float f6 = (f4 + f5) % 1.0f; float f7 = (vFullPath.mTrimPathEnd + f5) % 1.0f; if (this.mPathMeasure == null) { this.mPathMeasure = new PathMeasure(); } this.mPathMeasure.setPath(this.mPath, false); float length = this.mPathMeasure.getLength(); float f8 = f6 * length; float f9 = f7 * length; path.reset(); if (f8 > f9) { this.mPathMeasure.getSegment(f8, length, path, true); this.mPathMeasure.getSegment(0.0f, f9, path, true); } else { this.mPathMeasure.getSegment(f8, f9, path, true); } path.rLineTo(0.0f, 0.0f); } this.mRenderPath.addPath(path, this.mFinalPathMatrix); if (vFullPath.mFillColor.willDraw()) { ComplexColorCompat complexColorCompat = vFullPath.mFillColor; if (this.mFillPaint == null) { Paint paint = new Paint(1); this.mFillPaint = paint; paint.setStyle(Paint.Style.FILL); } Paint paint2 = this.mFillPaint; if (complexColorCompat.isGradient()) { Shader shader = complexColorCompat.getShader(); shader.setLocalMatrix(this.mFinalPathMatrix); paint2.setShader(shader); paint2.setAlpha(Math.round(vFullPath.mFillAlpha * 255.0f)); } else { paint2.setShader(null); paint2.setAlpha(255); paint2.setColor(VectorDrawableCompat.applyAlpha(complexColorCompat.getColor(), vFullPath.mFillAlpha)); } paint2.setColorFilter(colorFilter); this.mRenderPath.setFillType(vFullPath.mFillRule == 0 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD); canvas.drawPath(this.mRenderPath, paint2); } if (vFullPath.mStrokeColor.willDraw()) { ComplexColorCompat complexColorCompat2 = vFullPath.mStrokeColor; if (this.mStrokePaint == null) { Paint paint3 = new Paint(1); this.mStrokePaint = paint3; paint3.setStyle(Paint.Style.STROKE); } Paint paint4 = this.mStrokePaint; Paint.Join join = vFullPath.mStrokeLineJoin; if (join != null) { paint4.setStrokeJoin(join); } Paint.Cap cap = vFullPath.mStrokeLineCap; if (cap != null) { paint4.setStrokeCap(cap); } paint4.setStrokeMiter(vFullPath.mStrokeMiterlimit); if (complexColorCompat2.isGradient()) { Shader shader2 = complexColorCompat2.getShader(); shader2.setLocalMatrix(this.mFinalPathMatrix); paint4.setShader(shader2); paint4.setAlpha(Math.round(vFullPath.mStrokeAlpha * 255.0f)); } else { paint4.setShader(null); paint4.setAlpha(255); paint4.setColor(VectorDrawableCompat.applyAlpha(complexColorCompat2.getColor(), vFullPath.mStrokeAlpha)); } paint4.setColorFilter(colorFilter); paint4.setStrokeWidth(vFullPath.mStrokeWidth * fMin * matrixScale); canvas.drawPath(this.mRenderPath, paint4); } } private float getMatrixScale(Matrix matrix) { float[] fArr = {0.0f, 1.0f, 1.0f, 0.0f}; matrix.mapVectors(fArr); float fHypot = (float) Math.hypot(fArr[0], fArr[1]); float fHypot2 = (float) Math.hypot(fArr[2], fArr[3]); float fCross = cross(fArr[0], fArr[1], fArr[2], fArr[3]); float fMax = Math.max(fHypot, fHypot2); if (fMax > 0.0f) { return Math.abs(fCross) / fMax; } return 0.0f; } public void draw(Canvas canvas, int i2, int i3, ColorFilter colorFilter) { drawGroupTree(this.mRootGroup, IDENTITY_MATRIX, canvas, i2, i3, colorFilter); } public float getAlpha() { return getRootAlpha() / 255.0f; } public int getRootAlpha() { return this.mRootAlpha; } public boolean isStateful() { if (this.mIsStateful == null) { this.mIsStateful = Boolean.valueOf(this.mRootGroup.isStateful()); } return this.mIsStateful.booleanValue(); } public boolean onStateChanged(int[] iArr) { return this.mRootGroup.onStateChanged(iArr); } public void setAlpha(float f2) { setRootAlpha((int) (f2 * 255.0f)); } public void setRootAlpha(int i2) { this.mRootAlpha = i2; } public VPathRenderer(VPathRenderer vPathRenderer) { this.mFinalPathMatrix = new Matrix(); this.mBaseWidth = 0.0f; this.mBaseHeight = 0.0f; this.mViewportWidth = 0.0f; this.mViewportHeight = 0.0f; this.mRootAlpha = 255; this.mRootName = null; this.mIsStateful = null; ArrayMap arrayMap = new ArrayMap<>(); this.mVGTargetsMap = arrayMap; this.mRootGroup = new VGroup(vPathRenderer.mRootGroup, arrayMap); this.mPath = new Path(vPathRenderer.mPath); this.mRenderPath = new Path(vPathRenderer.mRenderPath); this.mBaseWidth = vPathRenderer.mBaseWidth; this.mBaseHeight = vPathRenderer.mBaseHeight; this.mViewportWidth = vPathRenderer.mViewportWidth; this.mViewportHeight = vPathRenderer.mViewportHeight; this.mChangingConfigurations = vPathRenderer.mChangingConfigurations; this.mRootAlpha = vPathRenderer.mRootAlpha; this.mRootName = vPathRenderer.mRootName; String str = vPathRenderer.mRootName; if (str != null) { arrayMap.put(str, this); } this.mIsStateful = vPathRenderer.mIsStateful; } } private static class VGroup extends VObject { int mChangingConfigurations; final ArrayList mChildren; private String mGroupName; final Matrix mLocalMatrix; private float mPivotX; private float mPivotY; float mRotate; private float mScaleX; private float mScaleY; final Matrix mStackedMatrix; private int[] mThemeAttrs; private float mTranslateX; private float mTranslateY; public VGroup(VGroup vGroup, ArrayMap arrayMap) { VPath vClipPath; super(); this.mStackedMatrix = new Matrix(); this.mChildren = new ArrayList<>(); this.mRotate = 0.0f; this.mPivotX = 0.0f; this.mPivotY = 0.0f; this.mScaleX = 1.0f; this.mScaleY = 1.0f; this.mTranslateX = 0.0f; this.mTranslateY = 0.0f; Matrix matrix = new Matrix(); this.mLocalMatrix = matrix; this.mGroupName = null; this.mRotate = vGroup.mRotate; this.mPivotX = vGroup.mPivotX; this.mPivotY = vGroup.mPivotY; this.mScaleX = vGroup.mScaleX; this.mScaleY = vGroup.mScaleY; this.mTranslateX = vGroup.mTranslateX; this.mTranslateY = vGroup.mTranslateY; this.mThemeAttrs = vGroup.mThemeAttrs; String str = vGroup.mGroupName; this.mGroupName = str; this.mChangingConfigurations = vGroup.mChangingConfigurations; if (str != null) { arrayMap.put(str, this); } matrix.set(vGroup.mLocalMatrix); ArrayList arrayList = vGroup.mChildren; for (int i2 = 0; i2 < arrayList.size(); i2++) { VObject vObject = arrayList.get(i2); if (vObject instanceof VGroup) { this.mChildren.add(new VGroup((VGroup) vObject, arrayMap)); } else { if (vObject instanceof VFullPath) { vClipPath = new VFullPath((VFullPath) vObject); } else { if (!(vObject instanceof VClipPath)) { throw new IllegalStateException("Unknown object in the tree!"); } vClipPath = new VClipPath((VClipPath) vObject); } this.mChildren.add(vClipPath); String str2 = vClipPath.mPathName; if (str2 != null) { arrayMap.put(str2, vClipPath); } } } } private void updateLocalMatrix() { this.mLocalMatrix.reset(); this.mLocalMatrix.postTranslate(-this.mPivotX, -this.mPivotY); this.mLocalMatrix.postScale(this.mScaleX, this.mScaleY); this.mLocalMatrix.postRotate(this.mRotate, 0.0f, 0.0f); this.mLocalMatrix.postTranslate(this.mTranslateX + this.mPivotX, this.mTranslateY + this.mPivotY); } private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser) { this.mThemeAttrs = null; this.mRotate = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "rotation", 5, this.mRotate); this.mPivotX = typedArray.getFloat(1, this.mPivotX); this.mPivotY = typedArray.getFloat(2, this.mPivotY); this.mScaleX = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "scaleX", 3, this.mScaleX); this.mScaleY = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "scaleY", 4, this.mScaleY); this.mTranslateX = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "translateX", 6, this.mTranslateX); this.mTranslateY = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "translateY", 7, this.mTranslateY); String string = typedArray.getString(0); if (string != null) { this.mGroupName = string; } updateLocalMatrix(); } public String getGroupName() { return this.mGroupName; } public Matrix getLocalMatrix() { return this.mLocalMatrix; } public float getPivotX() { return this.mPivotX; } public float getPivotY() { return this.mPivotY; } public float getRotation() { return this.mRotate; } public float getScaleX() { return this.mScaleX; } public float getScaleY() { return this.mScaleY; } public float getTranslateX() { return this.mTranslateX; } public float getTranslateY() { return this.mTranslateY; } public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) { TypedArray typedArrayObtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_GROUP); updateStateFromTypedArray(typedArrayObtainAttributes, xmlPullParser); typedArrayObtainAttributes.recycle(); } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject public boolean isStateful() { for (int i2 = 0; i2 < this.mChildren.size(); i2++) { if (this.mChildren.get(i2).isStateful()) { return true; } } return false; } @Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject public boolean onStateChanged(int[] iArr) { boolean zOnStateChanged = false; for (int i2 = 0; i2 < this.mChildren.size(); i2++) { zOnStateChanged |= this.mChildren.get(i2).onStateChanged(iArr); } return zOnStateChanged; } public void setPivotX(float f2) { if (f2 != this.mPivotX) { this.mPivotX = f2; updateLocalMatrix(); } } public void setPivotY(float f2) { if (f2 != this.mPivotY) { this.mPivotY = f2; updateLocalMatrix(); } } public void setRotation(float f2) { if (f2 != this.mRotate) { this.mRotate = f2; updateLocalMatrix(); } } public void setScaleX(float f2) { if (f2 != this.mScaleX) { this.mScaleX = f2; updateLocalMatrix(); } } public void setScaleY(float f2) { if (f2 != this.mScaleY) { this.mScaleY = f2; updateLocalMatrix(); } } public void setTranslateX(float f2) { if (f2 != this.mTranslateX) { this.mTranslateX = f2; updateLocalMatrix(); } } public void setTranslateY(float f2) { if (f2 != this.mTranslateY) { this.mTranslateY = f2; updateLocalMatrix(); } } public VGroup() { super(); this.mStackedMatrix = new Matrix(); this.mChildren = new ArrayList<>(); this.mRotate = 0.0f; this.mPivotX = 0.0f; this.mPivotY = 0.0f; this.mScaleX = 1.0f; this.mScaleY = 1.0f; this.mTranslateX = 0.0f; this.mTranslateY = 0.0f; this.mLocalMatrix = new Matrix(); this.mGroupName = null; } } }