CrackMe.apk
Download file
package androidx.appcompat.graphics.drawable;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Outline;
import android.graphics.PorterDuff;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.SystemClock;
import android.util.SparseArray;
import androidx.core.graphics.drawable.DrawableCompat;
class DrawableContainer extends Drawable implements Drawable.Callback {
private static final boolean DEBUG = false;
private static final boolean DEFAULT_DITHER = true;
private static final String TAG = "DrawableContainer";
private int mAlpha = 255;
private Runnable mAnimationRunnable;
private BlockInvalidateCallback mBlockInvalidateCallback;
private int mCurIndex = -1;
private Drawable mCurrDrawable;
private DrawableContainerState mDrawableContainerState;
private long mEnterAnimationEnd;
private long mExitAnimationEnd;
private boolean mHasAlpha;
private Rect mHotspotBounds;
private Drawable mLastDrawable;
private boolean mMutated;
DrawableContainer() {
}
public void draw(Canvas canvas) {
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
drawable.draw(canvas);
}
Drawable drawable2 = this.mLastDrawable;
if (drawable2 != null) {
drawable2.draw(canvas);
}
}
public int getChangingConfigurations() {
return super.getChangingConfigurations() | this.mDrawableContainerState.getChangingConfigurations();
}
private boolean needsMirroring() {
if (!isAutoMirrored() || DrawableCompat.getLayoutDirection(this) != 1) {
return false;
}
return true;
}
public boolean getPadding(Rect rect) {
boolean z;
Rect constantPadding = this.mDrawableContainerState.getConstantPadding();
if (constantPadding != null) {
rect.set(constantPadding);
z = (constantPadding.right | ((constantPadding.left | constantPadding.top) | constantPadding.bottom)) != 0;
} else {
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
z = drawable.getPadding(rect);
} else {
z = super.getPadding(rect);
}
}
if (needsMirroring()) {
int i = rect.left;
rect.left = rect.right;
rect.right = i;
}
return z;
}
public void getOutline(Outline outline) {
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
Api21Impl.getOutline(drawable, outline);
}
}
public void setAlpha(int i) {
if (!this.mHasAlpha || this.mAlpha != i) {
this.mHasAlpha = true;
this.mAlpha = i;
Drawable drawable = this.mCurrDrawable;
if (drawable == null) {
return;
}
if (this.mEnterAnimationEnd == 0) {
drawable.setAlpha(i);
} else {
animate(false);
}
}
}
public int getAlpha() {
return this.mAlpha;
}
public void setDither(boolean z) {
if (this.mDrawableContainerState.mDither != z) {
this.mDrawableContainerState.mDither = z;
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
drawable.setDither(this.mDrawableContainerState.mDither);
}
}
}
public void setColorFilter(ColorFilter colorFilter) {
this.mDrawableContainerState.mHasColorFilter = true;
if (this.mDrawableContainerState.mColorFilter != colorFilter) {
this.mDrawableContainerState.mColorFilter = colorFilter;
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
drawable.setColorFilter(colorFilter);
}
}
}
public void setTintList(ColorStateList colorStateList) {
this.mDrawableContainerState.mHasTintList = true;
if (this.mDrawableContainerState.mTintList != colorStateList) {
this.mDrawableContainerState.mTintList = colorStateList;
DrawableCompat.setTintList(this.mCurrDrawable, colorStateList);
}
}
public void setTintMode(PorterDuff.Mode mode) {
this.mDrawableContainerState.mHasTintMode = true;
if (this.mDrawableContainerState.mTintMode != mode) {
this.mDrawableContainerState.mTintMode = mode;
DrawableCompat.setTintMode(this.mCurrDrawable, mode);
}
}
public void setEnterFadeDuration(int i) {
this.mDrawableContainerState.mEnterFadeDuration = i;
}
public void setExitFadeDuration(int i) {
this.mDrawableContainerState.mExitFadeDuration = i;
}
/* access modifiers changed from: protected */
public void onBoundsChange(Rect rect) {
Drawable drawable = this.mLastDrawable;
if (drawable != null) {
drawable.setBounds(rect);
}
Drawable drawable2 = this.mCurrDrawable;
if (drawable2 != null) {
drawable2.setBounds(rect);
}
}
public boolean isStateful() {
return this.mDrawableContainerState.isStateful();
}
public void setAutoMirrored(boolean z) {
if (this.mDrawableContainerState.mAutoMirrored != z) {
this.mDrawableContainerState.mAutoMirrored = z;
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
DrawableCompat.setAutoMirrored(drawable, this.mDrawableContainerState.mAutoMirrored);
}
}
}
public boolean isAutoMirrored() {
return this.mDrawableContainerState.mAutoMirrored;
}
public void jumpToCurrentState() {
boolean z;
Drawable drawable = this.mLastDrawable;
boolean z2 = true;
if (drawable != null) {
drawable.jumpToCurrentState();
this.mLastDrawable = null;
z = true;
} else {
z = false;
}
Drawable drawable2 = this.mCurrDrawable;
if (drawable2 != null) {
drawable2.jumpToCurrentState();
if (this.mHasAlpha) {
this.mCurrDrawable.setAlpha(this.mAlpha);
}
}
if (this.mExitAnimationEnd != 0) {
this.mExitAnimationEnd = 0;
z = true;
}
if (this.mEnterAnimationEnd != 0) {
this.mEnterAnimationEnd = 0;
} else {
z2 = z;
}
if (z2) {
invalidateSelf();
}
}
public void setHotspot(float f, float f2) {
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
DrawableCompat.setHotspot(drawable, f, f2);
}
}
public void setHotspotBounds(int i, int i2, int i3, int i4) {
Rect rect = this.mHotspotBounds;
if (rect == null) {
this.mHotspotBounds = new Rect(i, i2, i3, i4);
} else {
rect.set(i, i2, i3, i4);
}
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
DrawableCompat.setHotspotBounds(drawable, i, i2, i3, i4);
}
}
public void getHotspotBounds(Rect rect) {
Rect rect2 = this.mHotspotBounds;
if (rect2 != null) {
rect.set(rect2);
} else {
super.getHotspotBounds(rect);
}
}
/* access modifiers changed from: protected */
public boolean onStateChange(int[] iArr) {
Drawable drawable = this.mLastDrawable;
if (drawable != null) {
return drawable.setState(iArr);
}
Drawable drawable2 = this.mCurrDrawable;
if (drawable2 != null) {
return drawable2.setState(iArr);
}
return false;
}
/* access modifiers changed from: protected */
public boolean onLevelChange(int i) {
Drawable drawable = this.mLastDrawable;
if (drawable != null) {
return drawable.setLevel(i);
}
Drawable drawable2 = this.mCurrDrawable;
if (drawable2 != null) {
return drawable2.setLevel(i);
}
return false;
}
public boolean onLayoutDirectionChanged(int i) {
return this.mDrawableContainerState.setLayoutDirection(i, getCurrentIndex());
}
public int getIntrinsicWidth() {
if (this.mDrawableContainerState.isConstantSize()) {
return this.mDrawableContainerState.getConstantWidth();
}
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
return drawable.getIntrinsicWidth();
}
return -1;
}
public int getIntrinsicHeight() {
if (this.mDrawableContainerState.isConstantSize()) {
return this.mDrawableContainerState.getConstantHeight();
}
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
return drawable.getIntrinsicHeight();
}
return -1;
}
public int getMinimumWidth() {
if (this.mDrawableContainerState.isConstantSize()) {
return this.mDrawableContainerState.getConstantMinimumWidth();
}
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
return drawable.getMinimumWidth();
}
return 0;
}
public int getMinimumHeight() {
if (this.mDrawableContainerState.isConstantSize()) {
return this.mDrawableContainerState.getConstantMinimumHeight();
}
Drawable drawable = this.mCurrDrawable;
if (drawable != null) {
return drawable.getMinimumHeight();
}
return 0;
}
public void invalidateDrawable(Drawable drawable) {
DrawableContainerState drawableContainerState = this.mDrawableContainerState;
if (drawableContainerState != null) {
drawableContainerState.invalidateCache();
}
if (drawable == this.mCurrDrawable && getCallback() != null) {
getCallback().invalidateDrawable(this);
}
}
public void scheduleDrawable(Drawable drawable, Runnable runnable, long j) {
if (drawable == this.mCurrDrawable && getCallback() != null) {
getCallback().scheduleDrawable(this, runnable, j);
}
}
public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
if (drawable == this.mCurrDrawable && getCallback() != null) {
getCallback().unscheduleDrawable(this, runnable);
}
}
public boolean setVisible(boolean z, boolean z2) {
boolean visible = super.setVisible(z, z2);
Drawable drawable = this.mLastDrawable;
if (drawable != null) {
drawable.setVisible(z, z2);
}
Drawable drawable2 = this.mCurrDrawable;
if (drawable2 != null) {
drawable2.setVisible(z, z2);
}
return visible;
}
public int getOpacity() {
Drawable drawable = this.mCurrDrawable;
if (drawable == null || !drawable.isVisible()) {
return -2;
}
return this.mDrawableContainerState.getOpacity();
}
/* access modifiers changed from: package-private */
public void setCurrentIndex(int i) {
selectDrawable(i);
}
/* access modifiers changed from: package-private */
public int getCurrentIndex() {
return this.mCurIndex;
}
/* access modifiers changed from: package-private */
public boolean selectDrawable(int i) {
if (i == this.mCurIndex) {
return false;
}
long uptimeMillis = SystemClock.uptimeMillis();
if (this.mDrawableContainerState.mExitFadeDuration > 0) {
Drawable drawable = this.mLastDrawable;
if (drawable != null) {
drawable.setVisible(false, false);
}
Drawable drawable2 = this.mCurrDrawable;
if (drawable2 != null) {
this.mLastDrawable = drawable2;
this.mExitAnimationEnd = ((long) this.mDrawableContainerState.mExitFadeDuration) + uptimeMillis;
} else {
this.mLastDrawable = null;
this.mExitAnimationEnd = 0;
}
} else {
Drawable drawable3 = this.mCurrDrawable;
if (drawable3 != null) {
drawable3.setVisible(false, false);
}
}
if (i < 0 || i >= this.mDrawableContainerState.mNumChildren) {
this.mCurrDrawable = null;
this.mCurIndex = -1;
} else {
Drawable child = this.mDrawableContainerState.getChild(i);
this.mCurrDrawable = child;
this.mCurIndex = i;
if (child != null) {
if (this.mDrawableContainerState.mEnterFadeDuration > 0) {
this.mEnterAnimationEnd = uptimeMillis + ((long) this.mDrawableContainerState.mEnterFadeDuration);
}
initializeDrawableForDisplay(child);
}
}
if (!(this.mEnterAnimationEnd == 0 && this.mExitAnimationEnd == 0)) {
Runnable runnable = this.mAnimationRunnable;
if (runnable == null) {
this.mAnimationRunnable = new Runnable() {
public void run() {
DrawableContainer.this.animate(true);
DrawableContainer.this.invalidateSelf();
}
};
} else {
unscheduleSelf(runnable);
}
animate(true);
}
invalidateSelf();
return true;
}
private void initializeDrawableForDisplay(Drawable drawable) {
if (this.mBlockInvalidateCallback == null) {
this.mBlockInvalidateCallback = new BlockInvalidateCallback();
}
drawable.setCallback(this.mBlockInvalidateCallback.wrap(drawable.getCallback()));
try {
if (this.mDrawableContainerState.mEnterFadeDuration <= 0 && this.mHasAlpha) {
drawable.setAlpha(this.mAlpha);
}
if (this.mDrawableContainerState.mHasColorFilter) {
drawable.setColorFilter(this.mDrawableContainerState.mColorFilter);
} else {
if (this.mDrawableContainerState.mHasTintList) {
DrawableCompat.setTintList(drawable, this.mDrawableContainerState.mTintList);
}
if (this.mDrawableContainerState.mHasTintMode) {
DrawableCompat.setTintMode(drawable, this.mDrawableContainerState.mTintMode);
}
}
drawable.setVisible(isVisible(), true);
drawable.setDither(this.mDrawableContainerState.mDither);
drawable.setState(getState());
drawable.setLevel(getLevel());
drawable.setBounds(getBounds());
if (Build.VERSION.SDK_INT >= 23) {
DrawableCompat.setLayoutDirection(drawable, DrawableCompat.getLayoutDirection(this));
}
if (Build.VERSION.SDK_INT >= 19) {
DrawableCompat.setAutoMirrored(drawable, this.mDrawableContainerState.mAutoMirrored);
}
Rect rect = this.mHotspotBounds;
if (Build.VERSION.SDK_INT >= 21 && rect != null) {
DrawableCompat.setHotspotBounds(drawable, rect.left, rect.top, rect.right, rect.bottom);
}
} finally {
drawable.setCallback(this.mBlockInvalidateCallback.unwrap());
}
}
/* access modifiers changed from: package-private */
/* JADX WARNING: Removed duplicated region for block: B:12:0x0041 */
/* JADX WARNING: Removed duplicated region for block: B:18:0x0069 */
/* JADX WARNING: Removed duplicated region for block: B:21:0x006e A[ADDED_TO_REGION] */
/* JADX WARNING: Removed duplicated region for block: B:24:? A[ADDED_TO_REGION, RETURN, SYNTHETIC] */
/* Code decompiled incorrectly, please refer to instructions dump. */
public void animate(boolean r14) {
/*
r13 = this;
r0 = 1
r13.mHasAlpha = r0
long r1 = android.os.SystemClock.uptimeMillis()
android.graphics.drawable.Drawable r3 = r13.mCurrDrawable
r4 = 255(0xff, double:1.26E-321)
r6 = 0
r7 = 0
if (r3 == 0) goto L_0x003a
long r9 = r13.mEnterAnimationEnd
int r11 = (r9 > r7 ? 1 : (r9 == r7 ? 0 : -1))
if (r11 == 0) goto L_0x003c
int r11 = (r9 > r1 ? 1 : (r9 == r1 ? 0 : -1))
if (r11 > 0) goto L_0x0022
int r9 = r13.mAlpha
r3.setAlpha(r9)
r13.mEnterAnimationEnd = r7
goto L_0x003c
L_0x0022:
long r9 = r9 - r1
long r9 = r9 * r4
int r3 = (int) r9
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r9 = r13.mDrawableContainerState
int r9 = r9.mEnterFadeDuration
int r3 = r3 / r9
android.graphics.drawable.Drawable r9 = r13.mCurrDrawable
int r3 = 255 - r3
int r10 = r13.mAlpha
int r3 = r3 * r10
int r3 = r3 / 255
r9.setAlpha(r3)
r3 = 1
goto L_0x003d
L_0x003a:
r13.mEnterAnimationEnd = r7
L_0x003c:
r3 = 0
L_0x003d:
android.graphics.drawable.Drawable r9 = r13.mLastDrawable
if (r9 == 0) goto L_0x0069
long r10 = r13.mExitAnimationEnd
int r12 = (r10 > r7 ? 1 : (r10 == r7 ? 0 : -1))
if (r12 == 0) goto L_0x006b
int r12 = (r10 > r1 ? 1 : (r10 == r1 ? 0 : -1))
if (r12 > 0) goto L_0x0054
r9.setVisible(r6, r6)
r0 = 0
r13.mLastDrawable = r0
r13.mExitAnimationEnd = r7
goto L_0x006b
L_0x0054:
long r10 = r10 - r1
long r10 = r10 * r4
int r3 = (int) r10
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r4 = r13.mDrawableContainerState
int r4 = r4.mExitFadeDuration
int r3 = r3 / r4
android.graphics.drawable.Drawable r4 = r13.mLastDrawable
int r5 = r13.mAlpha
int r3 = r3 * r5
int r3 = r3 / 255
r4.setAlpha(r3)
goto L_0x006c
L_0x0069:
r13.mExitAnimationEnd = r7
L_0x006b:
r0 = r3
L_0x006c:
if (r14 == 0) goto L_0x0078
if (r0 == 0) goto L_0x0078
java.lang.Runnable r14 = r13.mAnimationRunnable
r3 = 16
long r1 = r1 + r3
r13.scheduleSelf(r14, r1)
L_0x0078:
return
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.graphics.drawable.DrawableContainer.animate(boolean):void");
}
public Drawable getCurrent() {
return this.mCurrDrawable;
}
/* access modifiers changed from: package-private */
public final void updateDensity(Resources resources) {
this.mDrawableContainerState.updateDensity(resources);
}
public void applyTheme(Resources.Theme theme) {
this.mDrawableContainerState.applyTheme(theme);
}
public boolean canApplyTheme() {
return this.mDrawableContainerState.canApplyTheme();
}
public final Drawable.ConstantState getConstantState() {
if (!this.mDrawableContainerState.canConstantState()) {
return null;
}
this.mDrawableContainerState.mChangingConfigurations = getChangingConfigurations();
return this.mDrawableContainerState;
}
public Drawable mutate() {
if (!this.mMutated && super.mutate() == this) {
DrawableContainerState cloneConstantState = cloneConstantState();
cloneConstantState.mutate();
setConstantState(cloneConstantState);
this.mMutated = true;
}
return this;
}
/* access modifiers changed from: package-private */
public DrawableContainerState cloneConstantState() {
return this.mDrawableContainerState;
}
/* access modifiers changed from: package-private */
public void clearMutated() {
this.mDrawableContainerState.clearMutated();
this.mMutated = false;
}
static abstract class DrawableContainerState extends Drawable.ConstantState {
boolean mAutoMirrored;
boolean mCanConstantState;
int mChangingConfigurations;
boolean mCheckedConstantSize;
boolean mCheckedConstantState;
boolean mCheckedOpacity;
boolean mCheckedPadding;
boolean mCheckedStateful;
int mChildrenChangingConfigurations;
ColorFilter mColorFilter;
int mConstantHeight;
int mConstantMinimumHeight;
int mConstantMinimumWidth;
Rect mConstantPadding;
boolean mConstantSize = false;
int mConstantWidth;
int mDensity;
boolean mDither = true;
SparseArray<Drawable.ConstantState> mDrawableFutures;
Drawable[] mDrawables;
int mEnterFadeDuration = 0;
int mExitFadeDuration = 0;
boolean mHasColorFilter;
boolean mHasTintList;
boolean mHasTintMode;
int mLayoutDirection;
boolean mMutated;
int mNumChildren;
int mOpacity;
final DrawableContainer mOwner;
Resources mSourceRes;
boolean mStateful;
ColorStateList mTintList;
PorterDuff.Mode mTintMode;
boolean mVariablePadding = false;
DrawableContainerState(DrawableContainerState drawableContainerState, DrawableContainer drawableContainer, Resources resources) {
Resources resources2;
this.mOwner = drawableContainer;
Rect rect = null;
if (resources != null) {
resources2 = resources;
} else {
resources2 = drawableContainerState != null ? drawableContainerState.mSourceRes : null;
}
this.mSourceRes = resources2;
int resolveDensity = DrawableContainer.resolveDensity(resources, drawableContainerState != null ? drawableContainerState.mDensity : 0);
this.mDensity = resolveDensity;
if (drawableContainerState != null) {
this.mChangingConfigurations = drawableContainerState.mChangingConfigurations;
this.mChildrenChangingConfigurations = drawableContainerState.mChildrenChangingConfigurations;
this.mCheckedConstantState = true;
this.mCanConstantState = true;
this.mVariablePadding = drawableContainerState.mVariablePadding;
this.mConstantSize = drawableContainerState.mConstantSize;
this.mDither = drawableContainerState.mDither;
this.mMutated = drawableContainerState.mMutated;
this.mLayoutDirection = drawableContainerState.mLayoutDirection;
this.mEnterFadeDuration = drawableContainerState.mEnterFadeDuration;
this.mExitFadeDuration = drawableContainerState.mExitFadeDuration;
this.mAutoMirrored = drawableContainerState.mAutoMirrored;
this.mColorFilter = drawableContainerState.mColorFilter;
this.mHasColorFilter = drawableContainerState.mHasColorFilter;
this.mTintList = drawableContainerState.mTintList;
this.mTintMode = drawableContainerState.mTintMode;
this.mHasTintList = drawableContainerState.mHasTintList;
this.mHasTintMode = drawableContainerState.mHasTintMode;
if (drawableContainerState.mDensity == resolveDensity) {
if (drawableContainerState.mCheckedPadding) {
this.mConstantPadding = drawableContainerState.mConstantPadding != null ? new Rect(drawableContainerState.mConstantPadding) : rect;
this.mCheckedPadding = true;
}
if (drawableContainerState.mCheckedConstantSize) {
this.mConstantWidth = drawableContainerState.mConstantWidth;
this.mConstantHeight = drawableContainerState.mConstantHeight;
this.mConstantMinimumWidth = drawableContainerState.mConstantMinimumWidth;
this.mConstantMinimumHeight = drawableContainerState.mConstantMinimumHeight;
this.mCheckedConstantSize = true;
}
}
if (drawableContainerState.mCheckedOpacity) {
this.mOpacity = drawableContainerState.mOpacity;
this.mCheckedOpacity = true;
}
if (drawableContainerState.mCheckedStateful) {
this.mStateful = drawableContainerState.mStateful;
this.mCheckedStateful = true;
}
Drawable[] drawableArr = drawableContainerState.mDrawables;
this.mDrawables = new Drawable[drawableArr.length];
this.mNumChildren = drawableContainerState.mNumChildren;
SparseArray<Drawable.ConstantState> sparseArray = drawableContainerState.mDrawableFutures;
if (sparseArray != null) {
this.mDrawableFutures = sparseArray.clone();
} else {
this.mDrawableFutures = new SparseArray<>(this.mNumChildren);
}
int i = this.mNumChildren;
for (int i2 = 0; i2 < i; i2++) {
if (drawableArr[i2] != null) {
Drawable.ConstantState constantState = drawableArr[i2].getConstantState();
if (constantState != null) {
this.mDrawableFutures.put(i2, constantState);
} else {
this.mDrawables[i2] = drawableArr[i2];
}
}
}
return;
}
this.mDrawables = new Drawable[10];
this.mNumChildren = 0;
}
public int getChangingConfigurations() {
return this.mChangingConfigurations | this.mChildrenChangingConfigurations;
}
public final int addChild(Drawable drawable) {
int i = this.mNumChildren;
if (i >= this.mDrawables.length) {
growArray(i, i + 10);
}
drawable.mutate();
drawable.setVisible(false, true);
drawable.setCallback(this.mOwner);
this.mDrawables[i] = drawable;
this.mNumChildren++;
this.mChildrenChangingConfigurations = drawable.getChangingConfigurations() | this.mChildrenChangingConfigurations;
invalidateCache();
this.mConstantPadding = null;
this.mCheckedPadding = false;
this.mCheckedConstantSize = false;
this.mCheckedConstantState = false;
return i;
}
/* access modifiers changed from: package-private */
public void invalidateCache() {
this.mCheckedOpacity = false;
this.mCheckedStateful = false;
}
/* access modifiers changed from: package-private */
public final int getCapacity() {
return this.mDrawables.length;
}
private void createAllFutures() {
SparseArray<Drawable.ConstantState> sparseArray = this.mDrawableFutures;
if (sparseArray != null) {
int size = sparseArray.size();
for (int i = 0; i < size; i++) {
this.mDrawables[this.mDrawableFutures.keyAt(i)] = prepareDrawable(this.mDrawableFutures.valueAt(i).newDrawable(this.mSourceRes));
}
this.mDrawableFutures = null;
}
}
private Drawable prepareDrawable(Drawable drawable) {
if (Build.VERSION.SDK_INT >= 23) {
DrawableCompat.setLayoutDirection(drawable, this.mLayoutDirection);
}
Drawable mutate = drawable.mutate();
mutate.setCallback(this.mOwner);
return mutate;
}
public final int getChildCount() {
return this.mNumChildren;
}
public final Drawable getChild(int i) {
int indexOfKey;
Drawable drawable = this.mDrawables[i];
if (drawable != null) {
return drawable;
}
SparseArray<Drawable.ConstantState> sparseArray = this.mDrawableFutures;
if (sparseArray == null || (indexOfKey = sparseArray.indexOfKey(i)) < 0) {
return null;
}
Drawable prepareDrawable = prepareDrawable(this.mDrawableFutures.valueAt(indexOfKey).newDrawable(this.mSourceRes));
this.mDrawables[i] = prepareDrawable;
this.mDrawableFutures.removeAt(indexOfKey);
if (this.mDrawableFutures.size() == 0) {
this.mDrawableFutures = null;
}
return prepareDrawable;
}
/* access modifiers changed from: package-private */
public final boolean setLayoutDirection(int i, int i2) {
int i3 = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
boolean z = false;
for (int i4 = 0; i4 < i3; i4++) {
if (drawableArr[i4] != null) {
boolean layoutDirection = Build.VERSION.SDK_INT >= 23 ? DrawableCompat.setLayoutDirection(drawableArr[i4], i) : false;
if (i4 == i2) {
z = layoutDirection;
}
}
}
this.mLayoutDirection = i;
return z;
}
/* access modifiers changed from: package-private */
public final void updateDensity(Resources resources) {
if (resources != null) {
this.mSourceRes = resources;
int resolveDensity = DrawableContainer.resolveDensity(resources, this.mDensity);
int i = this.mDensity;
this.mDensity = resolveDensity;
if (i != resolveDensity) {
this.mCheckedConstantSize = false;
this.mCheckedPadding = false;
}
}
}
/* access modifiers changed from: package-private */
public final void applyTheme(Resources.Theme theme) {
if (theme != null) {
createAllFutures();
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
for (int i2 = 0; i2 < i; i2++) {
if (drawableArr[i2] != null && DrawableCompat.canApplyTheme(drawableArr[i2])) {
DrawableCompat.applyTheme(drawableArr[i2], theme);
this.mChildrenChangingConfigurations |= drawableArr[i2].getChangingConfigurations();
}
}
updateDensity(Api21Impl.getResources(theme));
}
}
public boolean canApplyTheme() {
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
for (int i2 = 0; i2 < i; i2++) {
Drawable drawable = drawableArr[i2];
if (drawable == null) {
Drawable.ConstantState constantState = this.mDrawableFutures.get(i2);
if (constantState != null && Api21Impl.canApplyTheme(constantState)) {
return true;
}
} else if (DrawableCompat.canApplyTheme(drawable)) {
return true;
}
}
return false;
}
/* access modifiers changed from: package-private */
public void mutate() {
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
for (int i2 = 0; i2 < i; i2++) {
if (drawableArr[i2] != null) {
drawableArr[i2].mutate();
}
}
this.mMutated = true;
}
/* access modifiers changed from: package-private */
public final void clearMutated() {
this.mMutated = false;
}
public final void setVariablePadding(boolean z) {
this.mVariablePadding = z;
}
public final Rect getConstantPadding() {
Rect rect = null;
if (this.mVariablePadding) {
return null;
}
Rect rect2 = this.mConstantPadding;
if (rect2 != null || this.mCheckedPadding) {
return rect2;
}
createAllFutures();
Rect rect3 = new Rect();
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
for (int i2 = 0; i2 < i; i2++) {
if (drawableArr[i2].getPadding(rect3)) {
if (rect == null) {
rect = new Rect(0, 0, 0, 0);
}
if (rect3.left > rect.left) {
rect.left = rect3.left;
}
if (rect3.top > rect.top) {
rect.top = rect3.top;
}
if (rect3.right > rect.right) {
rect.right = rect3.right;
}
if (rect3.bottom > rect.bottom) {
rect.bottom = rect3.bottom;
}
}
}
this.mCheckedPadding = true;
this.mConstantPadding = rect;
return rect;
}
public final void setConstantSize(boolean z) {
this.mConstantSize = z;
}
public final boolean isConstantSize() {
return this.mConstantSize;
}
public final int getConstantWidth() {
if (!this.mCheckedConstantSize) {
computeConstantSize();
}
return this.mConstantWidth;
}
public final int getConstantHeight() {
if (!this.mCheckedConstantSize) {
computeConstantSize();
}
return this.mConstantHeight;
}
public final int getConstantMinimumWidth() {
if (!this.mCheckedConstantSize) {
computeConstantSize();
}
return this.mConstantMinimumWidth;
}
public final int getConstantMinimumHeight() {
if (!this.mCheckedConstantSize) {
computeConstantSize();
}
return this.mConstantMinimumHeight;
}
/* access modifiers changed from: protected */
public void computeConstantSize() {
this.mCheckedConstantSize = true;
createAllFutures();
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
this.mConstantHeight = -1;
this.mConstantWidth = -1;
this.mConstantMinimumHeight = 0;
this.mConstantMinimumWidth = 0;
for (int i2 = 0; i2 < i; i2++) {
Drawable drawable = drawableArr[i2];
int intrinsicWidth = drawable.getIntrinsicWidth();
if (intrinsicWidth > this.mConstantWidth) {
this.mConstantWidth = intrinsicWidth;
}
int intrinsicHeight = drawable.getIntrinsicHeight();
if (intrinsicHeight > this.mConstantHeight) {
this.mConstantHeight = intrinsicHeight;
}
int minimumWidth = drawable.getMinimumWidth();
if (minimumWidth > this.mConstantMinimumWidth) {
this.mConstantMinimumWidth = minimumWidth;
}
int minimumHeight = drawable.getMinimumHeight();
if (minimumHeight > this.mConstantMinimumHeight) {
this.mConstantMinimumHeight = minimumHeight;
}
}
}
public final void setEnterFadeDuration(int i) {
this.mEnterFadeDuration = i;
}
public final int getEnterFadeDuration() {
return this.mEnterFadeDuration;
}
public final void setExitFadeDuration(int i) {
this.mExitFadeDuration = i;
}
public final int getExitFadeDuration() {
return this.mExitFadeDuration;
}
public final int getOpacity() {
if (this.mCheckedOpacity) {
return this.mOpacity;
}
createAllFutures();
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
int opacity = i > 0 ? drawableArr[0].getOpacity() : -2;
for (int i2 = 1; i2 < i; i2++) {
opacity = Drawable.resolveOpacity(opacity, drawableArr[i2].getOpacity());
}
this.mOpacity = opacity;
this.mCheckedOpacity = true;
return opacity;
}
public final boolean isStateful() {
if (this.mCheckedStateful) {
return this.mStateful;
}
createAllFutures();
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
boolean z = false;
int i2 = 0;
while (true) {
if (i2 >= i) {
break;
} else if (drawableArr[i2].isStateful()) {
z = true;
break;
} else {
i2++;
}
}
this.mStateful = z;
this.mCheckedStateful = true;
return z;
}
public void growArray(int i, int i2) {
Drawable[] drawableArr = new Drawable[i2];
Drawable[] drawableArr2 = this.mDrawables;
if (drawableArr2 != null) {
System.arraycopy(drawableArr2, 0, drawableArr, 0, i);
}
this.mDrawables = drawableArr;
}
public boolean canConstantState() {
if (this.mCheckedConstantState) {
return this.mCanConstantState;
}
createAllFutures();
this.mCheckedConstantState = true;
int i = this.mNumChildren;
Drawable[] drawableArr = this.mDrawables;
for (int i2 = 0; i2 < i; i2++) {
if (drawableArr[i2].getConstantState() == null) {
this.mCanConstantState = false;
return false;
}
}
this.mCanConstantState = true;
return true;
}
}
/* access modifiers changed from: package-private */
public void setConstantState(DrawableContainerState drawableContainerState) {
this.mDrawableContainerState = drawableContainerState;
int i = this.mCurIndex;
if (i >= 0) {
Drawable child = drawableContainerState.getChild(i);
this.mCurrDrawable = child;
if (child != null) {
initializeDrawableForDisplay(child);
}
}
this.mLastDrawable = null;
}
static class BlockInvalidateCallback implements Drawable.Callback {
private Drawable.Callback mCallback;
public void invalidateDrawable(Drawable drawable) {
}
BlockInvalidateCallback() {
}
public BlockInvalidateCallback wrap(Drawable.Callback callback) {
this.mCallback = callback;
return this;
}
public Drawable.Callback unwrap() {
Drawable.Callback callback = this.mCallback;
this.mCallback = null;
return callback;
}
public void scheduleDrawable(Drawable drawable, Runnable runnable, long j) {
Drawable.Callback callback = this.mCallback;
if (callback != null) {
callback.scheduleDrawable(drawable, runnable, j);
}
}
public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
Drawable.Callback callback = this.mCallback;
if (callback != null) {
callback.unscheduleDrawable(drawable, runnable);
}
}
}
static int resolveDensity(Resources resources, int i) {
if (resources != null) {
i = resources.getDisplayMetrics().densityDpi;
}
if (i == 0) {
return 160;
}
return i;
}
private static class Api21Impl {
private Api21Impl() {
}
public static boolean canApplyTheme(Drawable.ConstantState constantState) {
return constantState.canApplyTheme();
}
public static Resources getResources(Resources.Theme theme) {
return theme.getResources();
}
public static void getOutline(Drawable drawable, Outline outline) {
drawable.getOutline(outline);
}
}
}
Download file