CrackMe.apk
Download file
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.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import androidx.collection.ArrayMap;
import androidx.core.content.res.ComplexColorCompat;
import androidx.core.content.res.TypedArrayUtils;
import androidx.core.graphics.PathParser;
import androidx.core.graphics.drawable.DrawableCompat;
import androidx.core.view.ViewCompat;
import com.facebook.react.uimanager.ViewProps;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
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;
public /* bridge */ /* synthetic */ void applyTheme(Resources.Theme theme) {
super.applyTheme(theme);
}
public /* bridge */ /* synthetic */ void clearColorFilter() {
super.clearColorFilter();
}
public /* bridge */ /* synthetic */ Drawable getCurrent() {
return super.getCurrent();
}
public /* bridge */ /* synthetic */ int getMinimumHeight() {
return super.getMinimumHeight();
}
public /* bridge */ /* synthetic */ int getMinimumWidth() {
return super.getMinimumWidth();
}
public /* bridge */ /* synthetic */ boolean getPadding(Rect rect) {
return super.getPadding(rect);
}
public /* bridge */ /* synthetic */ int[] getState() {
return super.getState();
}
public /* bridge */ /* synthetic */ Region getTransparentRegion() {
return super.getTransparentRegion();
}
public /* bridge */ /* synthetic */ void jumpToCurrentState() {
super.jumpToCurrentState();
}
public /* bridge */ /* synthetic */ void setChangingConfigurations(int i) {
super.setChangingConfigurations(i);
}
public /* bridge */ /* synthetic */ void setColorFilter(int i, PorterDuff.Mode mode) {
super.setColorFilter(i, mode);
}
public /* bridge */ /* synthetic */ void setFilterBitmap(boolean z) {
super.setFilterBitmap(z);
}
public /* bridge */ /* synthetic */ void setHotspot(float f, float f2) {
super.setHotspot(f, f2);
}
public /* bridge */ /* synthetic */ void setHotspotBounds(int i, int i2, int i3, int i4) {
super.setHotspotBounds(i, i2, i3, i4);
}
public /* bridge */ /* synthetic */ boolean setState(int[] iArr) {
return super.setState(iArr);
}
VectorDrawableCompat() {
this.mAllowCaching = true;
this.mTmpFloats = new float[9];
this.mTmpMatrix = new Matrix();
this.mTmpBounds = new Rect();
this.mVectorState = new VectorDrawableCompatState();
}
VectorDrawableCompat(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);
}
public Drawable mutate() {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.mutate();
return this;
}
if (!this.mMutated && super.mutate() == this) {
this.mVectorState = new VectorDrawableCompatState(this.mVectorState);
this.mMutated = true;
}
return this;
}
/* access modifiers changed from: package-private */
public Object getTargetByName(String str) {
return this.mVectorState.mVPathRenderer.mVGTargetsMap.get(str);
}
public Drawable.ConstantState getConstantState() {
if (this.mDelegateDrawable != null && Build.VERSION.SDK_INT >= 24) {
return new VectorDrawableDelegateState(this.mDelegateDrawable.getConstantState());
}
this.mVectorState.mChangingConfigurations = getChangingConfigurations();
return this.mVectorState;
}
public void draw(Canvas canvas) {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.draw(canvas);
return;
}
copyBounds(this.mTmpBounds);
if (this.mTmpBounds.width() > 0 && this.mTmpBounds.height() > 0) {
ColorFilter colorFilter = this.mColorFilter;
if (colorFilter == null) {
colorFilter = this.mTintFilter;
}
canvas.getMatrix(this.mTmpMatrix);
this.mTmpMatrix.getValues(this.mTmpFloats);
float abs = Math.abs(this.mTmpFloats[0]);
float abs2 = Math.abs(this.mTmpFloats[4]);
float abs3 = Math.abs(this.mTmpFloats[1]);
float abs4 = Math.abs(this.mTmpFloats[3]);
if (!(abs3 == 0.0f && abs4 == 0.0f)) {
abs = 1.0f;
abs2 = 1.0f;
}
int min = Math.min(2048, (int) (((float) this.mTmpBounds.width()) * abs));
int min2 = Math.min(2048, (int) (((float) this.mTmpBounds.height()) * abs2));
if (min > 0 && min2 > 0) {
int save = canvas.save();
canvas.translate((float) this.mTmpBounds.left, (float) this.mTmpBounds.top);
if (needMirroring()) {
canvas.translate((float) this.mTmpBounds.width(), 0.0f);
canvas.scale(-1.0f, 1.0f);
}
this.mTmpBounds.offsetTo(0, 0);
this.mVectorState.createCachedBitmapIfNeeded(min, min2);
if (!this.mAllowCaching) {
this.mVectorState.updateCachedBitmap(min, min2);
} else if (!this.mVectorState.canReuseCache()) {
this.mVectorState.updateCachedBitmap(min, min2);
this.mVectorState.updateCacheStates();
}
this.mVectorState.drawCachedBitmapWithRootAlpha(canvas, colorFilter, this.mTmpBounds);
canvas.restoreToCount(save);
}
}
}
public int getAlpha() {
if (this.mDelegateDrawable != null) {
return DrawableCompat.getAlpha(this.mDelegateDrawable);
}
return this.mVectorState.mVPathRenderer.getRootAlpha();
}
public void setAlpha(int i) {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.setAlpha(i);
} else if (this.mVectorState.mVPathRenderer.getRootAlpha() != i) {
this.mVectorState.mVPathRenderer.setRootAlpha(i);
invalidateSelf();
}
}
public void setColorFilter(ColorFilter colorFilter) {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.setColorFilter(colorFilter);
return;
}
this.mColorFilter = colorFilter;
invalidateSelf();
}
public ColorFilter getColorFilter() {
if (this.mDelegateDrawable != null) {
return DrawableCompat.getColorFilter(this.mDelegateDrawable);
}
return this.mColorFilter;
}
/* access modifiers changed from: package-private */
public PorterDuffColorFilter updateTintFilter(PorterDuffColorFilter porterDuffColorFilter, ColorStateList colorStateList, PorterDuff.Mode mode) {
if (colorStateList == null || mode == null) {
return null;
}
return new PorterDuffColorFilter(colorStateList.getColorForState(getState(), 0), mode);
}
public void setTint(int i) {
if (this.mDelegateDrawable != null) {
DrawableCompat.setTint(this.mDelegateDrawable, i);
} else {
setTintList(ColorStateList.valueOf(i));
}
}
public void setTintList(ColorStateList colorStateList) {
if (this.mDelegateDrawable != null) {
DrawableCompat.setTintList(this.mDelegateDrawable, colorStateList);
return;
}
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
if (vectorDrawableCompatState.mTint != colorStateList) {
vectorDrawableCompatState.mTint = colorStateList;
this.mTintFilter = updateTintFilter(this.mTintFilter, colorStateList, vectorDrawableCompatState.mTintMode);
invalidateSelf();
}
}
public void setTintMode(PorterDuff.Mode mode) {
if (this.mDelegateDrawable != null) {
DrawableCompat.setTintMode(this.mDelegateDrawable, mode);
return;
}
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
if (vectorDrawableCompatState.mTintMode != mode) {
vectorDrawableCompatState.mTintMode = mode;
this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, mode);
invalidateSelf();
}
}
/* JADX WARNING: Code restructure failed: missing block: B:6:0x0011, code lost:
r0 = r1.mVectorState;
*/
/* Code decompiled incorrectly, please refer to instructions dump. */
public boolean isStateful() {
/*
r1 = this;
android.graphics.drawable.Drawable r0 = r1.mDelegateDrawable
if (r0 == 0) goto L_0x000b
android.graphics.drawable.Drawable r0 = r1.mDelegateDrawable
boolean r0 = r0.isStateful()
return r0
L_0x000b:
boolean r0 = super.isStateful()
if (r0 != 0) goto L_0x002e
androidx.vectordrawable.graphics.drawable.VectorDrawableCompat$VectorDrawableCompatState r0 = r1.mVectorState
if (r0 == 0) goto L_0x002c
boolean r0 = r0.isStateful()
if (r0 != 0) goto L_0x002e
androidx.vectordrawable.graphics.drawable.VectorDrawableCompat$VectorDrawableCompatState r0 = r1.mVectorState
android.content.res.ColorStateList r0 = r0.mTint
if (r0 == 0) goto L_0x002c
androidx.vectordrawable.graphics.drawable.VectorDrawableCompat$VectorDrawableCompatState r0 = r1.mVectorState
android.content.res.ColorStateList r0 = r0.mTint
boolean r0 = r0.isStateful()
if (r0 == 0) goto L_0x002c
goto L_0x002e
L_0x002c:
r0 = 0
goto L_0x002f
L_0x002e:
r0 = 1
L_0x002f:
return r0
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.isStateful():boolean");
}
/* access modifiers changed from: protected */
public boolean onStateChange(int[] iArr) {
if (this.mDelegateDrawable != null) {
return this.mDelegateDrawable.setState(iArr);
}
boolean z = false;
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
if (!(vectorDrawableCompatState.mTint == null || vectorDrawableCompatState.mTintMode == null)) {
this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, vectorDrawableCompatState.mTintMode);
invalidateSelf();
z = true;
}
if (!vectorDrawableCompatState.isStateful() || !vectorDrawableCompatState.onStateChanged(iArr)) {
return z;
}
invalidateSelf();
return true;
}
public int getOpacity() {
if (this.mDelegateDrawable != null) {
return this.mDelegateDrawable.getOpacity();
}
return -3;
}
public int getIntrinsicWidth() {
if (this.mDelegateDrawable != null) {
return this.mDelegateDrawable.getIntrinsicWidth();
}
return (int) this.mVectorState.mVPathRenderer.mBaseWidth;
}
public int getIntrinsicHeight() {
if (this.mDelegateDrawable != null) {
return this.mDelegateDrawable.getIntrinsicHeight();
}
return (int) this.mVectorState.mVPathRenderer.mBaseHeight;
}
public boolean canApplyTheme() {
if (this.mDelegateDrawable == null) {
return false;
}
DrawableCompat.canApplyTheme(this.mDelegateDrawable);
return false;
}
public boolean isAutoMirrored() {
if (this.mDelegateDrawable != null) {
return DrawableCompat.isAutoMirrored(this.mDelegateDrawable);
}
return this.mVectorState.mAutoMirrored;
}
public void setAutoMirrored(boolean z) {
if (this.mDelegateDrawable != null) {
DrawableCompat.setAutoMirrored(this.mDelegateDrawable, z);
} else {
this.mVectorState.mAutoMirrored = z;
}
}
public float getPixelSize() {
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
if (vectorDrawableCompatState == null || vectorDrawableCompatState.mVPathRenderer == null || this.mVectorState.mVPathRenderer.mBaseWidth == 0.0f || this.mVectorState.mVPathRenderer.mBaseHeight == 0.0f || this.mVectorState.mVPathRenderer.mViewportHeight == 0.0f || this.mVectorState.mVPathRenderer.mViewportWidth == 0.0f) {
return 1.0f;
}
float f = this.mVectorState.mVPathRenderer.mBaseWidth;
float f2 = this.mVectorState.mVPathRenderer.mBaseHeight;
return Math.min(this.mVectorState.mVPathRenderer.mViewportWidth / f, this.mVectorState.mVPathRenderer.mViewportHeight / f2);
}
/* JADX WARNING: Removed duplicated region for block: B:12:0x0038 A[Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }] */
/* JADX WARNING: Removed duplicated region for block: B:14:0x003d A[Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }] */
/* Code decompiled incorrectly, please refer to instructions dump. */
public static androidx.vectordrawable.graphics.drawable.VectorDrawableCompat create(android.content.res.Resources r6, int r7, android.content.res.Resources.Theme r8) {
/*
java.lang.String r0 = "parser error"
java.lang.String r1 = "VectorDrawableCompat"
int r2 = android.os.Build.VERSION.SDK_INT
r3 = 24
if (r2 < r3) goto L_0x0023
androidx.vectordrawable.graphics.drawable.VectorDrawableCompat r0 = new androidx.vectordrawable.graphics.drawable.VectorDrawableCompat
r0.<init>()
android.graphics.drawable.Drawable r6 = androidx.core.content.res.ResourcesCompat.getDrawable(r6, r7, r8)
r0.mDelegateDrawable = r6
androidx.vectordrawable.graphics.drawable.VectorDrawableCompat$VectorDrawableDelegateState r6 = new androidx.vectordrawable.graphics.drawable.VectorDrawableCompat$VectorDrawableDelegateState
android.graphics.drawable.Drawable r7 = r0.mDelegateDrawable
android.graphics.drawable.Drawable$ConstantState r7 = r7.getConstantState()
r6.<init>(r7)
r0.mCachedConstantStateDelegate = r6
return r0
L_0x0023:
android.content.res.XmlResourceParser r7 = r6.getXml(r7) // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
android.util.AttributeSet r2 = android.util.Xml.asAttributeSet(r7) // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
L_0x002b:
int r3 = r7.next() // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
r4 = 2
if (r3 == r4) goto L_0x0036
r5 = 1
if (r3 == r5) goto L_0x0036
goto L_0x002b
L_0x0036:
if (r3 != r4) goto L_0x003d
androidx.vectordrawable.graphics.drawable.VectorDrawableCompat r6 = createFromXmlInner(r6, r7, r2, r8) // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
return r6
L_0x003d:
org.xmlpull.v1.XmlPullParserException r6 = new org.xmlpull.v1.XmlPullParserException // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
java.lang.String r7 = "No start tag found"
r6.<init>(r7) // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
throw r6 // Catch:{ XmlPullParserException -> 0x004a, IOException -> 0x0045 }
L_0x0045:
r6 = move-exception
android.util.Log.e(r1, r0, r6)
goto L_0x004e
L_0x004a:
r6 = move-exception
android.util.Log.e(r1, r0, r6)
L_0x004e:
r6 = 0
return r6
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.create(android.content.res.Resources, int, android.content.res.Resources$Theme):androidx.vectordrawable.graphics.drawable.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;
}
static int applyAlpha(int i, float f) {
return (i & ViewCompat.MEASURED_SIZE_MASK) | (((int) (((float) Color.alpha(i)) * f)) << 24);
}
public void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet) throws XmlPullParserException, IOException {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.inflate(resources, xmlPullParser, attributeSet);
} else {
inflate(resources, xmlPullParser, attributeSet, (Resources.Theme) null);
}
}
public void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException {
if (this.mDelegateDrawable != null) {
DrawableCompat.inflate(this.mDelegateDrawable, resources, xmlPullParser, attributeSet, theme);
return;
}
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
vectorDrawableCompatState.mVPathRenderer = new VPathRenderer();
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_TYPE_ARRAY);
updateStateFromTypedArray(obtainAttributes, xmlPullParser, theme);
obtainAttributes.recycle();
vectorDrawableCompatState.mChangingConfigurations = getChangingConfigurations();
vectorDrawableCompatState.mCacheDirty = true;
inflateInternal(resources, xmlPullParser, attributeSet, theme);
this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, vectorDrawableCompatState.mTintMode);
}
private static PorterDuff.Mode parseTintModeCompat(int i, PorterDuff.Mode mode) {
if (i == 3) {
return PorterDuff.Mode.SRC_OVER;
}
if (i == 5) {
return PorterDuff.Mode.SRC_IN;
}
if (i == 9) {
return PorterDuff.Mode.SRC_ATOP;
}
switch (i) {
case 14:
return PorterDuff.Mode.MULTIPLY;
case 15:
return PorterDuff.Mode.SCREEN;
case 16:
return PorterDuff.Mode.ADD;
default:
return mode;
}
}
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);
vPathRenderer.mViewportHeight = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "viewportHeight", 8, vPathRenderer.mViewportHeight);
if (vPathRenderer.mViewportWidth <= 0.0f) {
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires viewportWidth > 0");
} else if (vPathRenderer.mViewportHeight > 0.0f) {
vPathRenderer.mBaseWidth = typedArray.getDimension(3, vPathRenderer.mBaseWidth);
vPathRenderer.mBaseHeight = typedArray.getDimension(2, vPathRenderer.mBaseHeight);
if (vPathRenderer.mBaseWidth <= 0.0f) {
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires width > 0");
} else if (vPathRenderer.mBaseHeight > 0.0f) {
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);
}
} else {
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires height > 0");
}
} else {
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires viewportHeight > 0");
}
}
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 z = 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);
}
z = false;
vectorDrawableCompatState.mChangingConfigurations = vFullPath.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations;
} 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 (z) {
throw new XmlPullParserException("no path defined");
}
}
private void printGroupTree(VGroup vGroup, int i) {
String str = "";
for (int i2 = 0; i2 < i; i2++) {
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 i3 = 0; i3 < vGroup.mChildren.size(); i3++) {
VObject vObject = vGroup.mChildren.get(i3);
if (vObject instanceof VGroup) {
printGroupTree((VGroup) vObject, i + 1);
} else {
((VPath) vObject).printVPath(i + 1);
}
}
}
/* access modifiers changed from: package-private */
public void setAllowCaching(boolean z) {
this.mAllowCaching = z;
}
private boolean needMirroring() {
if (Build.VERSION.SDK_INT < 17 || !isAutoMirrored() || DrawableCompat.getLayoutDirection(this) != 1) {
return false;
}
return true;
}
/* access modifiers changed from: protected */
public void onBoundsChange(Rect rect) {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.setBounds(rect);
}
}
public int getChangingConfigurations() {
if (this.mDelegateDrawable != null) {
return this.mDelegateDrawable.getChangingConfigurations();
}
return super.getChangingConfigurations() | this.mVectorState.getChangingConfigurations();
}
public void invalidateSelf() {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.invalidateSelf();
} else {
super.invalidateSelf();
}
}
public void scheduleSelf(Runnable runnable, long j) {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.scheduleSelf(runnable, j);
} else {
super.scheduleSelf(runnable, j);
}
}
public boolean setVisible(boolean z, boolean z2) {
if (this.mDelegateDrawable != null) {
return this.mDelegateDrawable.setVisible(z, z2);
}
return super.setVisible(z, z2);
}
public void unscheduleSelf(Runnable runnable) {
if (this.mDelegateDrawable != null) {
this.mDelegateDrawable.unscheduleSelf(runnable);
} else {
super.unscheduleSelf(runnable);
}
}
private static class VectorDrawableDelegateState extends Drawable.ConstantState {
private final Drawable.ConstantState mDelegateState;
public VectorDrawableDelegateState(Drawable.ConstantState constantState) {
this.mDelegateState = constantState;
}
public Drawable newDrawable() {
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable();
return vectorDrawableCompat;
}
public Drawable newDrawable(Resources resources) {
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(resources);
return vectorDrawableCompat;
}
public Drawable newDrawable(Resources resources, Resources.Theme theme) {
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(resources, theme);
return vectorDrawableCompat;
}
public boolean canApplyTheme() {
return this.mDelegateState.canApplyTheme();
}
public int getChangingConfigurations() {
return this.mDelegateState.getChangingConfigurations();
}
}
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;
this.mVPathRenderer = new VPathRenderer(vectorDrawableCompatState.mVPathRenderer);
if (vectorDrawableCompatState.mVPathRenderer.mFillPaint != null) {
this.mVPathRenderer.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 void drawCachedBitmapWithRootAlpha(Canvas canvas, ColorFilter colorFilter, Rect rect) {
canvas.drawBitmap(this.mCachedBitmap, (Rect) null, rect, getPaint(colorFilter));
}
public boolean hasTranslucentRoot() {
return this.mVPathRenderer.getRootAlpha() < 255;
}
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 void updateCachedBitmap(int i, int i2) {
this.mCachedBitmap.eraseColor(0);
this.mVPathRenderer.draw(new Canvas(this.mCachedBitmap), i, i2, (ColorFilter) null);
}
public void createCachedBitmapIfNeeded(int i, int i2) {
if (this.mCachedBitmap == null || !canReuseBitmap(i, i2)) {
this.mCachedBitmap = Bitmap.createBitmap(i, i2, Bitmap.Config.ARGB_8888);
this.mCacheDirty = true;
}
}
public boolean canReuseBitmap(int i, int i2) {
return i == this.mCachedBitmap.getWidth() && i2 == 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 updateCacheStates() {
this.mCachedTint = this.mTint;
this.mCachedTintMode = this.mTintMode;
this.mCachedRootAlpha = this.mVPathRenderer.getRootAlpha();
this.mCachedAutoMirrored = this.mAutoMirrored;
this.mCacheDirty = false;
}
public VectorDrawableCompatState() {
this.mTint = null;
this.mTintMode = VectorDrawableCompat.DEFAULT_TINT_MODE;
this.mVPathRenderer = new VPathRenderer();
}
public Drawable newDrawable() {
return new VectorDrawableCompat(this);
}
public Drawable newDrawable(Resources resources) {
return new VectorDrawableCompat(this);
}
public int getChangingConfigurations() {
return this.mChangingConfigurations;
}
public boolean isStateful() {
return this.mVPathRenderer.isStateful();
}
public boolean onStateChanged(int[] iArr) {
boolean onStateChanged = this.mVPathRenderer.onStateChanged(iArr);
this.mCacheDirty |= onStateChanged;
return onStateChanged;
}
}
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<String, Object> mVGTargetsMap;
float mViewportHeight;
float mViewportWidth;
private static float cross(float f, float f2, float f3, float f4) {
return (f * f4) - (f2 * f3);
}
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();
}
public void setRootAlpha(int i) {
this.mRootAlpha = i;
}
public int getRootAlpha() {
return this.mRootAlpha;
}
public void setAlpha(float f) {
setRootAlpha((int) (f * 255.0f));
}
public float getAlpha() {
return ((float) getRootAlpha()) / 255.0f;
}
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<String, Object> 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 void drawGroupTree(VGroup vGroup, Matrix matrix, Canvas canvas, int i, int i2, ColorFilter colorFilter) {
vGroup.mStackedMatrix.set(matrix);
vGroup.mStackedMatrix.preConcat(vGroup.mLocalMatrix);
canvas.save();
for (int i3 = 0; i3 < vGroup.mChildren.size(); i3++) {
VObject vObject = vGroup.mChildren.get(i3);
if (vObject instanceof VGroup) {
drawGroupTree((VGroup) vObject, vGroup.mStackedMatrix, canvas, i, i2, colorFilter);
} else if (vObject instanceof VPath) {
drawPath(vGroup, (VPath) vObject, canvas, i, i2, colorFilter);
}
}
canvas.restore();
}
public void draw(Canvas canvas, int i, int i2, ColorFilter colorFilter) {
drawGroupTree(this.mRootGroup, IDENTITY_MATRIX, canvas, i, i2, colorFilter);
}
private void drawPath(VGroup vGroup, VPath vPath, Canvas canvas, int i, int i2, ColorFilter colorFilter) {
float f = ((float) i) / this.mViewportWidth;
float f2 = ((float) i2) / this.mViewportHeight;
float min = Math.min(f, f2);
Matrix matrix = vGroup.mStackedMatrix;
this.mFinalPathMatrix.set(matrix);
this.mFinalPathMatrix.postScale(f, f2);
float matrixScale = getMatrixScale(matrix);
if (matrixScale != 0.0f) {
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;
if (!(vFullPath.mTrimPathStart == 0.0f && vFullPath.mTrimPathEnd == 1.0f)) {
float f3 = (vFullPath.mTrimPathStart + vFullPath.mTrimPathOffset) % 1.0f;
float f4 = (vFullPath.mTrimPathEnd + vFullPath.mTrimPathOffset) % 1.0f;
if (this.mPathMeasure == null) {
this.mPathMeasure = new PathMeasure();
}
this.mPathMeasure.setPath(this.mPath, false);
float length = this.mPathMeasure.getLength();
float f5 = f3 * length;
float f6 = f4 * length;
path.reset();
if (f5 > f6) {
this.mPathMeasure.getSegment(f5, length, path, true);
this.mPathMeasure.getSegment(0.0f, f6, path, true);
} else {
this.mPathMeasure.getSegment(f5, f6, 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((Shader) 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;
if (vFullPath.mStrokeLineJoin != null) {
paint4.setStrokeJoin(vFullPath.mStrokeLineJoin);
}
if (vFullPath.mStrokeLineCap != null) {
paint4.setStrokeCap(vFullPath.mStrokeLineCap);
}
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((Shader) null);
paint4.setAlpha(255);
paint4.setColor(VectorDrawableCompat.applyAlpha(complexColorCompat2.getColor(), vFullPath.mStrokeAlpha));
}
paint4.setColorFilter(colorFilter);
paint4.setStrokeWidth(vFullPath.mStrokeWidth * min * 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 cross = cross(fArr[0], fArr[1], fArr[2], fArr[3]);
float max = Math.max((float) Math.hypot((double) fArr[0], (double) fArr[1]), (float) Math.hypot((double) fArr[2], (double) fArr[3]));
if (max > 0.0f) {
return Math.abs(cross) / max;
}
return 0.0f;
}
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);
}
}
private static abstract class VObject {
public boolean isStateful() {
return false;
}
public boolean onStateChanged(int[] iArr) {
return false;
}
private VObject() {
}
}
private static class VGroup extends VObject {
int mChangingConfigurations;
final ArrayList<VObject> 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<String, Object> arrayMap) {
super();
VPath vPath;
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<VObject> arrayList = vGroup.mChildren;
for (int i = 0; i < arrayList.size(); i++) {
VObject vObject = arrayList.get(i);
if (vObject instanceof VGroup) {
this.mChildren.add(new VGroup((VGroup) vObject, arrayMap));
} else {
if (vObject instanceof VFullPath) {
vPath = new VFullPath((VFullPath) vObject);
} else if (vObject instanceof VClipPath) {
vPath = new VClipPath((VClipPath) vObject);
} else {
throw new IllegalStateException("Unknown object in the tree!");
}
this.mChildren.add(vPath);
if (vPath.mPathName != null) {
arrayMap.put(vPath.mPathName, vPath);
}
}
}
}
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;
}
public String getGroupName() {
return this.mGroupName;
}
public Matrix getLocalMatrix() {
return this.mLocalMatrix;
}
public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) {
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_GROUP);
updateStateFromTypedArray(obtainAttributes, xmlPullParser);
obtainAttributes.recycle();
}
private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser) {
this.mThemeAttrs = null;
this.mRotate = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, ViewProps.ROTATION, 5, this.mRotate);
this.mPivotX = typedArray.getFloat(1, this.mPivotX);
this.mPivotY = typedArray.getFloat(2, this.mPivotY);
this.mScaleX = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, ViewProps.SCALE_X, 3, this.mScaleX);
this.mScaleY = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, ViewProps.SCALE_Y, 4, this.mScaleY);
this.mTranslateX = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, ViewProps.TRANSLATE_X, 6, this.mTranslateX);
this.mTranslateY = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, ViewProps.TRANSLATE_Y, 7, this.mTranslateY);
String string = typedArray.getString(0);
if (string != null) {
this.mGroupName = string;
}
updateLocalMatrix();
}
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);
}
public float getRotation() {
return this.mRotate;
}
public void setRotation(float f) {
if (f != this.mRotate) {
this.mRotate = f;
updateLocalMatrix();
}
}
public float getPivotX() {
return this.mPivotX;
}
public void setPivotX(float f) {
if (f != this.mPivotX) {
this.mPivotX = f;
updateLocalMatrix();
}
}
public float getPivotY() {
return this.mPivotY;
}
public void setPivotY(float f) {
if (f != this.mPivotY) {
this.mPivotY = f;
updateLocalMatrix();
}
}
public float getScaleX() {
return this.mScaleX;
}
public void setScaleX(float f) {
if (f != this.mScaleX) {
this.mScaleX = f;
updateLocalMatrix();
}
}
public float getScaleY() {
return this.mScaleY;
}
public void setScaleY(float f) {
if (f != this.mScaleY) {
this.mScaleY = f;
updateLocalMatrix();
}
}
public float getTranslateX() {
return this.mTranslateX;
}
public void setTranslateX(float f) {
if (f != this.mTranslateX) {
this.mTranslateX = f;
updateLocalMatrix();
}
}
public float getTranslateY() {
return this.mTranslateY;
}
public void setTranslateY(float f) {
if (f != this.mTranslateY) {
this.mTranslateY = f;
updateLocalMatrix();
}
}
public boolean isStateful() {
for (int i = 0; i < this.mChildren.size(); i++) {
if (this.mChildren.get(i).isStateful()) {
return true;
}
}
return false;
}
public boolean onStateChanged(int[] iArr) {
boolean z = false;
for (int i = 0; i < this.mChildren.size(); i++) {
z |= this.mChildren.get(i).onStateChanged(iArr);
}
return z;
}
}
private static abstract class VPath extends VObject {
protected static final int FILL_TYPE_WINDING = 0;
int mChangingConfigurations;
int mFillRule = 0;
protected PathParser.PathDataNode[] mNodes = null;
String mPathName;
public void applyTheme(Resources.Theme theme) {
}
public boolean canApplyTheme() {
return false;
}
public boolean isClipPath() {
return false;
}
public VPath() {
super();
}
public void printVPath(int i) {
String str = "";
for (int i2 = 0; i2 < i; i2++) {
str = str + " ";
}
Log.v(VectorDrawableCompat.LOGTAG, str + "current path is :" + this.mPathName + " pathData is " + nodesToString(this.mNodes));
}
public String nodesToString(PathParser.PathDataNode[] pathDataNodeArr) {
String str = " ";
for (int i = 0; i < pathDataNodeArr.length; i++) {
str = str + pathDataNodeArr[i].mType + ":";
float[] fArr = pathDataNodeArr[i].mParams;
for (int i2 = 0; i2 < fArr.length; i2++) {
str = str + fArr[i2] + ",";
}
}
return str;
}
public VPath(VPath vPath) {
super();
this.mPathName = vPath.mPathName;
this.mChangingConfigurations = vPath.mChangingConfigurations;
this.mNodes = PathParser.deepCopyNodes(vPath.mNodes);
}
public void toPath(Path path) {
path.reset();
PathParser.PathDataNode[] pathDataNodeArr = this.mNodes;
if (pathDataNodeArr != null) {
PathParser.PathDataNode.nodesToPath(pathDataNodeArr, path);
}
}
public String getPathName() {
return this.mPathName;
}
public PathParser.PathDataNode[] getPathData() {
return this.mNodes;
}
public void setPathData(PathParser.PathDataNode[] pathDataNodeArr) {
if (!PathParser.canMorph(this.mNodes, pathDataNodeArr)) {
this.mNodes = PathParser.deepCopyNodes(pathDataNodeArr);
} else {
PathParser.updateNodes(this.mNodes, pathDataNodeArr);
}
}
}
private static class VClipPath extends VPath {
public boolean isClipPath() {
return true;
}
VClipPath() {
}
VClipPath(VClipPath vClipPath) {
super(vClipPath);
}
public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) {
if (TypedArrayUtils.hasAttribute(xmlPullParser, "pathData")) {
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_CLIP_PATH);
updateStateFromTypedArray(obtainAttributes, xmlPullParser);
obtainAttributes.recycle();
}
}
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);
}
}
private static class VFullPath extends VPath {
float mFillAlpha = 1.0f;
ComplexColorCompat mFillColor;
float mStrokeAlpha = 1.0f;
ComplexColorCompat mStrokeColor;
Paint.Cap mStrokeLineCap = Paint.Cap.BUTT;
Paint.Join mStrokeLineJoin = Paint.Join.MITER;
float mStrokeMiterlimit = 4.0f;
float mStrokeWidth = 0.0f;
private int[] mThemeAttrs;
float mTrimPathEnd = 1.0f;
float mTrimPathOffset = 0.0f;
float mTrimPathStart = 0.0f;
public void applyTheme(Resources.Theme theme) {
}
VFullPath() {
}
VFullPath(VFullPath vFullPath) {
super(vFullPath);
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 Paint.Cap getStrokeLineCap(int i, Paint.Cap cap) {
if (i == 0) {
return Paint.Cap.BUTT;
}
if (i != 1) {
return i != 2 ? cap : Paint.Cap.SQUARE;
}
return Paint.Cap.ROUND;
}
private Paint.Join getStrokeLineJoin(int i, Paint.Join join) {
if (i == 0) {
return Paint.Join.MITER;
}
if (i != 1) {
return i != 2 ? join : Paint.Join.BEVEL;
}
return Paint.Join.ROUND;
}
public boolean canApplyTheme() {
return this.mThemeAttrs != null;
}
public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) {
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_PATH);
updateStateFromTypedArray(obtainAttributes, xmlPullParser, theme);
obtainAttributes.recycle();
}
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);
}
Resources.Theme theme2 = theme;
this.mFillColor = TypedArrayUtils.getNamedComplexColor(typedArray, xmlPullParser, theme2, "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, theme2, "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);
}
}
public boolean isStateful() {
return this.mFillColor.isStateful() || this.mStrokeColor.isStateful();
}
public boolean onStateChanged(int[] iArr) {
return this.mStrokeColor.onStateChanged(iArr) | this.mFillColor.onStateChanged(iArr);
}
/* access modifiers changed from: package-private */
public int getStrokeColor() {
return this.mStrokeColor.getColor();
}
/* access modifiers changed from: package-private */
public void setStrokeColor(int i) {
this.mStrokeColor.setColor(i);
}
/* access modifiers changed from: package-private */
public float getStrokeWidth() {
return this.mStrokeWidth;
}
/* access modifiers changed from: package-private */
public void setStrokeWidth(float f) {
this.mStrokeWidth = f;
}
/* access modifiers changed from: package-private */
public float getStrokeAlpha() {
return this.mStrokeAlpha;
}
/* access modifiers changed from: package-private */
public void setStrokeAlpha(float f) {
this.mStrokeAlpha = f;
}
/* access modifiers changed from: package-private */
public int getFillColor() {
return this.mFillColor.getColor();
}
/* access modifiers changed from: package-private */
public void setFillColor(int i) {
this.mFillColor.setColor(i);
}
/* access modifiers changed from: package-private */
public float getFillAlpha() {
return this.mFillAlpha;
}
/* access modifiers changed from: package-private */
public void setFillAlpha(float f) {
this.mFillAlpha = f;
}
/* access modifiers changed from: package-private */
public float getTrimPathStart() {
return this.mTrimPathStart;
}
/* access modifiers changed from: package-private */
public void setTrimPathStart(float f) {
this.mTrimPathStart = f;
}
/* access modifiers changed from: package-private */
public float getTrimPathEnd() {
return this.mTrimPathEnd;
}
/* access modifiers changed from: package-private */
public void setTrimPathEnd(float f) {
this.mTrimPathEnd = f;
}
/* access modifiers changed from: package-private */
public float getTrimPathOffset() {
return this.mTrimPathOffset;
}
/* access modifiers changed from: package-private */
public void setTrimPathOffset(float f) {
this.mTrimPathOffset = f;
}
}
}
Download file