1112 lines
34 KiB
Java
1112 lines
34 KiB
Java
package androidx.appcompat.graphics.drawable;
|
|
|
|
import android.annotation.SuppressLint;
|
|
import android.annotation.TargetApi;
|
|
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.util.SparseArray;
|
|
import androidx.core.graphics.drawable.DrawableCompat;
|
|
|
|
/* loaded from: classes.dex */
|
|
class DrawableContainer extends Drawable implements Drawable.Callback {
|
|
private DrawableContainerState a;
|
|
private Rect b;
|
|
private Drawable c;
|
|
private Drawable d;
|
|
private boolean f;
|
|
private boolean h;
|
|
private Runnable i;
|
|
private long j;
|
|
private long k;
|
|
private BlockInvalidateCallback l;
|
|
private int e = 255;
|
|
private int g = -1;
|
|
|
|
static class BlockInvalidateCallback implements Drawable.Callback {
|
|
private Drawable.Callback a;
|
|
|
|
BlockInvalidateCallback() {
|
|
}
|
|
|
|
public BlockInvalidateCallback a(Drawable.Callback callback) {
|
|
this.a = callback;
|
|
return this;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.Callback
|
|
public void invalidateDrawable(Drawable drawable) {
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.Callback
|
|
public void scheduleDrawable(Drawable drawable, Runnable runnable, long j) {
|
|
Drawable.Callback callback = this.a;
|
|
if (callback != null) {
|
|
callback.scheduleDrawable(drawable, runnable, j);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.Callback
|
|
public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
|
|
Drawable.Callback callback = this.a;
|
|
if (callback != null) {
|
|
callback.unscheduleDrawable(drawable, runnable);
|
|
}
|
|
}
|
|
|
|
public Drawable.Callback a() {
|
|
Drawable.Callback callback = this.a;
|
|
this.a = null;
|
|
return callback;
|
|
}
|
|
}
|
|
|
|
static abstract class DrawableContainerState extends Drawable.ConstantState {
|
|
int A;
|
|
int B;
|
|
boolean C;
|
|
ColorFilter D;
|
|
boolean E;
|
|
ColorStateList F;
|
|
PorterDuff.Mode G;
|
|
boolean H;
|
|
boolean I;
|
|
final DrawableContainer a;
|
|
Resources b;
|
|
int c;
|
|
int d;
|
|
int e;
|
|
SparseArray<Drawable.ConstantState> f;
|
|
Drawable[] g;
|
|
int h;
|
|
boolean i;
|
|
boolean j;
|
|
Rect k;
|
|
boolean l;
|
|
boolean m;
|
|
int n;
|
|
int o;
|
|
int p;
|
|
int q;
|
|
boolean r;
|
|
int s;
|
|
boolean t;
|
|
boolean u;
|
|
boolean v;
|
|
boolean w;
|
|
boolean x;
|
|
boolean y;
|
|
int z;
|
|
|
|
DrawableContainerState(DrawableContainerState drawableContainerState, DrawableContainer drawableContainer, Resources resources) {
|
|
this.c = 160;
|
|
this.i = false;
|
|
this.l = false;
|
|
this.x = true;
|
|
this.A = 0;
|
|
this.B = 0;
|
|
this.a = drawableContainer;
|
|
this.b = resources != null ? resources : drawableContainerState != null ? drawableContainerState.b : null;
|
|
this.c = DrawableContainer.a(resources, drawableContainerState != null ? drawableContainerState.c : 0);
|
|
if (drawableContainerState == null) {
|
|
this.g = new Drawable[10];
|
|
this.h = 0;
|
|
return;
|
|
}
|
|
this.d = drawableContainerState.d;
|
|
this.e = drawableContainerState.e;
|
|
this.v = true;
|
|
this.w = true;
|
|
this.i = drawableContainerState.i;
|
|
this.l = drawableContainerState.l;
|
|
this.x = drawableContainerState.x;
|
|
this.y = drawableContainerState.y;
|
|
this.z = drawableContainerState.z;
|
|
this.A = drawableContainerState.A;
|
|
this.B = drawableContainerState.B;
|
|
this.C = drawableContainerState.C;
|
|
this.D = drawableContainerState.D;
|
|
this.E = drawableContainerState.E;
|
|
this.F = drawableContainerState.F;
|
|
this.G = drawableContainerState.G;
|
|
this.H = drawableContainerState.H;
|
|
this.I = drawableContainerState.I;
|
|
if (drawableContainerState.c == this.c) {
|
|
if (drawableContainerState.j) {
|
|
this.k = new Rect(drawableContainerState.k);
|
|
this.j = true;
|
|
}
|
|
if (drawableContainerState.m) {
|
|
this.n = drawableContainerState.n;
|
|
this.o = drawableContainerState.o;
|
|
this.p = drawableContainerState.p;
|
|
this.q = drawableContainerState.q;
|
|
this.m = true;
|
|
}
|
|
}
|
|
if (drawableContainerState.r) {
|
|
this.s = drawableContainerState.s;
|
|
this.r = true;
|
|
}
|
|
if (drawableContainerState.t) {
|
|
this.u = drawableContainerState.u;
|
|
this.t = true;
|
|
}
|
|
Drawable[] drawableArr = drawableContainerState.g;
|
|
this.g = new Drawable[drawableArr.length];
|
|
this.h = drawableContainerState.h;
|
|
SparseArray<Drawable.ConstantState> sparseArray = drawableContainerState.f;
|
|
if (sparseArray != null) {
|
|
this.f = sparseArray.clone();
|
|
} else {
|
|
this.f = new SparseArray<>(this.h);
|
|
}
|
|
int i = this.h;
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
if (drawableArr[i2] != null) {
|
|
Drawable.ConstantState constantState = drawableArr[i2].getConstantState();
|
|
if (constantState != null) {
|
|
this.f.put(i2, constantState);
|
|
} else {
|
|
this.g[i2] = drawableArr[i2];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Drawable b(Drawable drawable) {
|
|
if (Build.VERSION.SDK_INT >= 23) {
|
|
drawable.setLayoutDirection(this.z);
|
|
}
|
|
Drawable mutate = drawable.mutate();
|
|
mutate.setCallback(this.a);
|
|
return mutate;
|
|
}
|
|
|
|
private void n() {
|
|
SparseArray<Drawable.ConstantState> sparseArray = this.f;
|
|
if (sparseArray != null) {
|
|
int size = sparseArray.size();
|
|
for (int i = 0; i < size; i++) {
|
|
this.g[this.f.keyAt(i)] = b(this.f.valueAt(i).newDrawable(this.b));
|
|
}
|
|
this.f = null;
|
|
}
|
|
}
|
|
|
|
public final int a(Drawable drawable) {
|
|
int i = this.h;
|
|
if (i >= this.g.length) {
|
|
a(i, i + 10);
|
|
}
|
|
drawable.mutate();
|
|
drawable.setVisible(false, true);
|
|
drawable.setCallback(this.a);
|
|
this.g[i] = drawable;
|
|
this.h++;
|
|
this.e = drawable.getChangingConfigurations() | this.e;
|
|
k();
|
|
this.k = null;
|
|
this.j = false;
|
|
this.m = false;
|
|
this.v = false;
|
|
return i;
|
|
}
|
|
|
|
final int c() {
|
|
return this.g.length;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public boolean canApplyTheme() {
|
|
int i = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
Drawable drawable = drawableArr[i2];
|
|
if (drawable == null) {
|
|
Drawable.ConstantState constantState = this.f.get(i2);
|
|
if (constantState != null && constantState.canApplyTheme()) {
|
|
return true;
|
|
}
|
|
} else if (drawable.canApplyTheme()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public final int d() {
|
|
return this.h;
|
|
}
|
|
|
|
public final int e() {
|
|
if (!this.m) {
|
|
b();
|
|
}
|
|
return this.o;
|
|
}
|
|
|
|
public final int f() {
|
|
if (!this.m) {
|
|
b();
|
|
}
|
|
return this.q;
|
|
}
|
|
|
|
public final int g() {
|
|
if (!this.m) {
|
|
b();
|
|
}
|
|
return this.p;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public int getChangingConfigurations() {
|
|
return this.d | this.e;
|
|
}
|
|
|
|
public final Rect h() {
|
|
if (this.i) {
|
|
return null;
|
|
}
|
|
if (this.k != null || this.j) {
|
|
return this.k;
|
|
}
|
|
n();
|
|
Rect rect = new Rect();
|
|
int i = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
Rect rect2 = null;
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
if (drawableArr[i2].getPadding(rect)) {
|
|
if (rect2 == null) {
|
|
rect2 = new Rect(0, 0, 0, 0);
|
|
}
|
|
int i3 = rect.left;
|
|
if (i3 > rect2.left) {
|
|
rect2.left = i3;
|
|
}
|
|
int i4 = rect.top;
|
|
if (i4 > rect2.top) {
|
|
rect2.top = i4;
|
|
}
|
|
int i5 = rect.right;
|
|
if (i5 > rect2.right) {
|
|
rect2.right = i5;
|
|
}
|
|
int i6 = rect.bottom;
|
|
if (i6 > rect2.bottom) {
|
|
rect2.bottom = i6;
|
|
}
|
|
}
|
|
}
|
|
this.j = true;
|
|
this.k = rect2;
|
|
return rect2;
|
|
}
|
|
|
|
public final int i() {
|
|
if (!this.m) {
|
|
b();
|
|
}
|
|
return this.n;
|
|
}
|
|
|
|
public final int j() {
|
|
if (this.r) {
|
|
return this.s;
|
|
}
|
|
n();
|
|
int i = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
int opacity = i > 0 ? drawableArr[0].getOpacity() : -2;
|
|
for (int i2 = 1; i2 < i; i2++) {
|
|
opacity = Drawable.resolveOpacity(opacity, drawableArr[i2].getOpacity());
|
|
}
|
|
this.s = opacity;
|
|
this.r = true;
|
|
return opacity;
|
|
}
|
|
|
|
void k() {
|
|
this.r = false;
|
|
this.t = false;
|
|
}
|
|
|
|
public final boolean l() {
|
|
return this.l;
|
|
}
|
|
|
|
abstract void m();
|
|
|
|
public final void c(int i) {
|
|
this.B = i;
|
|
}
|
|
|
|
final boolean b(int i, int i2) {
|
|
int i3 = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
boolean z = false;
|
|
for (int i4 = 0; i4 < i3; i4++) {
|
|
if (drawableArr[i4] != null) {
|
|
boolean layoutDirection = Build.VERSION.SDK_INT >= 23 ? drawableArr[i4].setLayoutDirection(i) : false;
|
|
if (i4 == i2) {
|
|
z = layoutDirection;
|
|
}
|
|
}
|
|
}
|
|
this.z = i;
|
|
return z;
|
|
}
|
|
|
|
public final void b(boolean z) {
|
|
this.i = z;
|
|
}
|
|
|
|
protected void b() {
|
|
this.m = true;
|
|
n();
|
|
int i = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
this.o = -1;
|
|
this.n = -1;
|
|
this.q = 0;
|
|
this.p = 0;
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
Drawable drawable = drawableArr[i2];
|
|
int intrinsicWidth = drawable.getIntrinsicWidth();
|
|
if (intrinsicWidth > this.n) {
|
|
this.n = intrinsicWidth;
|
|
}
|
|
int intrinsicHeight = drawable.getIntrinsicHeight();
|
|
if (intrinsicHeight > this.o) {
|
|
this.o = intrinsicHeight;
|
|
}
|
|
int minimumWidth = drawable.getMinimumWidth();
|
|
if (minimumWidth > this.p) {
|
|
this.p = minimumWidth;
|
|
}
|
|
int minimumHeight = drawable.getMinimumHeight();
|
|
if (minimumHeight > this.q) {
|
|
this.q = minimumHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
public final Drawable a(int i) {
|
|
int indexOfKey;
|
|
Drawable drawable = this.g[i];
|
|
if (drawable != null) {
|
|
return drawable;
|
|
}
|
|
SparseArray<Drawable.ConstantState> sparseArray = this.f;
|
|
if (sparseArray == null || (indexOfKey = sparseArray.indexOfKey(i)) < 0) {
|
|
return null;
|
|
}
|
|
Drawable b = b(this.f.valueAt(indexOfKey).newDrawable(this.b));
|
|
this.g[i] = b;
|
|
this.f.removeAt(indexOfKey);
|
|
if (this.f.size() == 0) {
|
|
this.f = null;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
final void a(Resources resources) {
|
|
if (resources != null) {
|
|
this.b = resources;
|
|
int a = DrawableContainer.a(resources, this.c);
|
|
int i = this.c;
|
|
this.c = a;
|
|
if (i != a) {
|
|
this.m = false;
|
|
this.j = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void b(int i) {
|
|
this.A = i;
|
|
}
|
|
|
|
final void a(Resources.Theme theme) {
|
|
if (theme != null) {
|
|
n();
|
|
int i = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
if (drawableArr[i2] != null && drawableArr[i2].canApplyTheme()) {
|
|
drawableArr[i2].applyTheme(theme);
|
|
this.e |= drawableArr[i2].getChangingConfigurations();
|
|
}
|
|
}
|
|
a(theme.getResources());
|
|
}
|
|
}
|
|
|
|
public final void a(boolean z) {
|
|
this.l = z;
|
|
}
|
|
|
|
public void a(int i, int i2) {
|
|
Drawable[] drawableArr = new Drawable[i2];
|
|
System.arraycopy(this.g, 0, drawableArr, 0, i);
|
|
this.g = drawableArr;
|
|
}
|
|
|
|
public synchronized boolean a() {
|
|
if (this.v) {
|
|
return this.w;
|
|
}
|
|
n();
|
|
this.v = true;
|
|
int i = this.h;
|
|
Drawable[] drawableArr = this.g;
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
if (drawableArr[i2].getConstantState() == null) {
|
|
this.w = false;
|
|
return false;
|
|
}
|
|
}
|
|
this.w = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
DrawableContainer() {
|
|
}
|
|
|
|
@SuppressLint({"WrongConstant"})
|
|
@TargetApi(23)
|
|
private boolean c() {
|
|
return isAutoMirrored() && getLayoutDirection() == 1;
|
|
}
|
|
|
|
DrawableContainerState a() {
|
|
throw null;
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:30:0x006b */
|
|
/* JADX WARN: Removed duplicated region for block: B:32:0x0073 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct code enable 'Show inconsistent code' option in preferences
|
|
*/
|
|
boolean a(int r10) {
|
|
/*
|
|
r9 = this;
|
|
int r0 = r9.g
|
|
r1 = 0
|
|
if (r10 != r0) goto L6
|
|
return r1
|
|
L6:
|
|
long r2 = android.os.SystemClock.uptimeMillis()
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r0 = r9.a
|
|
int r0 = r0.B
|
|
r4 = 0
|
|
r5 = 0
|
|
if (r0 <= 0) goto L2e
|
|
android.graphics.drawable.Drawable r0 = r9.d
|
|
if (r0 == 0) goto L1a
|
|
r0.setVisible(r1, r1)
|
|
L1a:
|
|
android.graphics.drawable.Drawable r0 = r9.c
|
|
if (r0 == 0) goto L29
|
|
r9.d = r0
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r0 = r9.a
|
|
int r0 = r0.B
|
|
long r0 = (long) r0
|
|
long r0 = r0 + r2
|
|
r9.k = r0
|
|
goto L35
|
|
L29:
|
|
r9.d = r4
|
|
r9.k = r5
|
|
goto L35
|
|
L2e:
|
|
android.graphics.drawable.Drawable r0 = r9.c
|
|
if (r0 == 0) goto L35
|
|
r0.setVisible(r1, r1)
|
|
L35:
|
|
if (r10 < 0) goto L55
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r0 = r9.a
|
|
int r1 = r0.h
|
|
if (r10 >= r1) goto L55
|
|
android.graphics.drawable.Drawable r0 = r0.a(r10)
|
|
r9.c = r0
|
|
r9.g = r10
|
|
if (r0 == 0) goto L5a
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r10 = r9.a
|
|
int r10 = r10.A
|
|
if (r10 <= 0) goto L51
|
|
long r7 = (long) r10
|
|
long r2 = r2 + r7
|
|
r9.j = r2
|
|
L51:
|
|
r9.a(r0)
|
|
goto L5a
|
|
L55:
|
|
r9.c = r4
|
|
r10 = -1
|
|
r9.g = r10
|
|
L5a:
|
|
long r0 = r9.j
|
|
r10 = 1
|
|
int r2 = (r0 > r5 ? 1 : (r0 == r5 ? 0 : -1))
|
|
if (r2 != 0) goto L67
|
|
long r0 = r9.k
|
|
int r2 = (r0 > r5 ? 1 : (r0 == r5 ? 0 : -1))
|
|
if (r2 == 0) goto L79
|
|
L67:
|
|
java.lang.Runnable r0 = r9.i
|
|
if (r0 != 0) goto L73
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$1 r0 = new androidx.appcompat.graphics.drawable.DrawableContainer$1
|
|
r0.<init>()
|
|
r9.i = r0
|
|
goto L76
|
|
L73:
|
|
r9.unscheduleSelf(r0)
|
|
L76:
|
|
r9.a(r10)
|
|
L79:
|
|
r9.invalidateSelf()
|
|
return r10
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.graphics.drawable.DrawableContainer.a(int):boolean");
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void applyTheme(Resources.Theme theme) {
|
|
this.a.a(theme);
|
|
}
|
|
|
|
int b() {
|
|
return this.g;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean canApplyTheme() {
|
|
return this.a.canApplyTheme();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void draw(Canvas canvas) {
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
drawable.draw(canvas);
|
|
}
|
|
Drawable drawable2 = this.d;
|
|
if (drawable2 != null) {
|
|
drawable2.draw(canvas);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getAlpha() {
|
|
return this.e;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getChangingConfigurations() {
|
|
return super.getChangingConfigurations() | this.a.getChangingConfigurations();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public final Drawable.ConstantState getConstantState() {
|
|
if (!this.a.a()) {
|
|
return null;
|
|
}
|
|
this.a.d = getChangingConfigurations();
|
|
return this.a;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public Drawable getCurrent() {
|
|
return this.c;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void getHotspotBounds(Rect rect) {
|
|
Rect rect2 = this.b;
|
|
if (rect2 != null) {
|
|
rect.set(rect2);
|
|
} else {
|
|
super.getHotspotBounds(rect);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getIntrinsicHeight() {
|
|
if (this.a.l()) {
|
|
return this.a.e();
|
|
}
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
return drawable.getIntrinsicHeight();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getIntrinsicWidth() {
|
|
if (this.a.l()) {
|
|
return this.a.i();
|
|
}
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
return drawable.getIntrinsicWidth();
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getMinimumHeight() {
|
|
if (this.a.l()) {
|
|
return this.a.f();
|
|
}
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
return drawable.getMinimumHeight();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getMinimumWidth() {
|
|
if (this.a.l()) {
|
|
return this.a.g();
|
|
}
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
return drawable.getMinimumWidth();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getOpacity() {
|
|
Drawable drawable = this.c;
|
|
if (drawable == null || !drawable.isVisible()) {
|
|
return -2;
|
|
}
|
|
return this.a.j();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void getOutline(Outline outline) {
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
drawable.getOutline(outline);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean getPadding(Rect rect) {
|
|
boolean padding;
|
|
Rect h = this.a.h();
|
|
if (h != null) {
|
|
rect.set(h);
|
|
padding = (h.right | ((h.left | h.top) | h.bottom)) != 0;
|
|
} else {
|
|
Drawable drawable = this.c;
|
|
padding = drawable != null ? drawable.getPadding(rect) : super.getPadding(rect);
|
|
}
|
|
if (c()) {
|
|
int i = rect.left;
|
|
rect.left = rect.right;
|
|
rect.right = i;
|
|
}
|
|
return padding;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.Callback
|
|
public void invalidateDrawable(Drawable drawable) {
|
|
DrawableContainerState drawableContainerState = this.a;
|
|
if (drawableContainerState != null) {
|
|
drawableContainerState.k();
|
|
}
|
|
if (drawable != this.c || getCallback() == null) {
|
|
return;
|
|
}
|
|
getCallback().invalidateDrawable(this);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean isAutoMirrored() {
|
|
return this.a.C;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void jumpToCurrentState() {
|
|
boolean z;
|
|
Drawable drawable = this.d;
|
|
if (drawable != null) {
|
|
drawable.jumpToCurrentState();
|
|
this.d = null;
|
|
z = true;
|
|
} else {
|
|
z = false;
|
|
}
|
|
Drawable drawable2 = this.c;
|
|
if (drawable2 != null) {
|
|
drawable2.jumpToCurrentState();
|
|
if (this.f) {
|
|
this.c.setAlpha(this.e);
|
|
}
|
|
}
|
|
if (this.k != 0) {
|
|
this.k = 0L;
|
|
z = true;
|
|
}
|
|
if (this.j != 0) {
|
|
this.j = 0L;
|
|
z = true;
|
|
}
|
|
if (z) {
|
|
invalidateSelf();
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public Drawable mutate() {
|
|
if (!this.h && super.mutate() == this) {
|
|
DrawableContainerState a = a();
|
|
a.m();
|
|
a(a);
|
|
this.h = true;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
protected void onBoundsChange(Rect rect) {
|
|
Drawable drawable = this.d;
|
|
if (drawable != null) {
|
|
drawable.setBounds(rect);
|
|
}
|
|
Drawable drawable2 = this.c;
|
|
if (drawable2 != null) {
|
|
drawable2.setBounds(rect);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean onLayoutDirectionChanged(int i) {
|
|
return this.a.b(i, b());
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
protected boolean onLevelChange(int i) {
|
|
Drawable drawable = this.d;
|
|
if (drawable != null) {
|
|
return drawable.setLevel(i);
|
|
}
|
|
Drawable drawable2 = this.c;
|
|
if (drawable2 != null) {
|
|
return drawable2.setLevel(i);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
protected boolean onStateChange(int[] iArr) {
|
|
Drawable drawable = this.d;
|
|
if (drawable != null) {
|
|
return drawable.setState(iArr);
|
|
}
|
|
Drawable drawable2 = this.c;
|
|
if (drawable2 != null) {
|
|
return drawable2.setState(iArr);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.Callback
|
|
public void scheduleDrawable(Drawable drawable, Runnable runnable, long j) {
|
|
if (drawable != this.c || getCallback() == null) {
|
|
return;
|
|
}
|
|
getCallback().scheduleDrawable(this, runnable, j);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setAlpha(int i) {
|
|
if (this.f && this.e == i) {
|
|
return;
|
|
}
|
|
this.f = true;
|
|
this.e = i;
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
if (this.j == 0) {
|
|
drawable.setAlpha(i);
|
|
} else {
|
|
a(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setAutoMirrored(boolean z) {
|
|
DrawableContainerState drawableContainerState = this.a;
|
|
if (drawableContainerState.C != z) {
|
|
drawableContainerState.C = z;
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
DrawableCompat.a(drawable, drawableContainerState.C);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setColorFilter(ColorFilter colorFilter) {
|
|
DrawableContainerState drawableContainerState = this.a;
|
|
drawableContainerState.E = true;
|
|
if (drawableContainerState.D != colorFilter) {
|
|
drawableContainerState.D = colorFilter;
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
drawable.setColorFilter(colorFilter);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setDither(boolean z) {
|
|
DrawableContainerState drawableContainerState = this.a;
|
|
if (drawableContainerState.x != z) {
|
|
drawableContainerState.x = z;
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
drawable.setDither(drawableContainerState.x);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setHotspot(float f, float f2) {
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
DrawableCompat.a(drawable, f, f2);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setHotspotBounds(int i, int i2, int i3, int i4) {
|
|
Rect rect = this.b;
|
|
if (rect == null) {
|
|
this.b = new Rect(i, i2, i3, i4);
|
|
} else {
|
|
rect.set(i, i2, i3, i4);
|
|
}
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
DrawableCompat.a(drawable, i, i2, i3, i4);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setTintList(ColorStateList colorStateList) {
|
|
DrawableContainerState drawableContainerState = this.a;
|
|
drawableContainerState.H = true;
|
|
if (drawableContainerState.F != colorStateList) {
|
|
drawableContainerState.F = colorStateList;
|
|
DrawableCompat.a(this.c, colorStateList);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setTintMode(PorterDuff.Mode mode) {
|
|
DrawableContainerState drawableContainerState = this.a;
|
|
drawableContainerState.I = true;
|
|
if (drawableContainerState.G != mode) {
|
|
drawableContainerState.G = mode;
|
|
DrawableCompat.a(this.c, mode);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean setVisible(boolean z, boolean z2) {
|
|
boolean visible = super.setVisible(z, z2);
|
|
Drawable drawable = this.d;
|
|
if (drawable != null) {
|
|
drawable.setVisible(z, z2);
|
|
}
|
|
Drawable drawable2 = this.c;
|
|
if (drawable2 != null) {
|
|
drawable2.setVisible(z, z2);
|
|
}
|
|
return visible;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.Callback
|
|
public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
|
|
if (drawable != this.c || getCallback() == null) {
|
|
return;
|
|
}
|
|
getCallback().unscheduleDrawable(this, runnable);
|
|
}
|
|
|
|
private void a(Drawable drawable) {
|
|
if (this.l == null) {
|
|
this.l = new BlockInvalidateCallback();
|
|
}
|
|
BlockInvalidateCallback blockInvalidateCallback = this.l;
|
|
blockInvalidateCallback.a(drawable.getCallback());
|
|
drawable.setCallback(blockInvalidateCallback);
|
|
try {
|
|
if (this.a.A <= 0 && this.f) {
|
|
drawable.setAlpha(this.e);
|
|
}
|
|
if (this.a.E) {
|
|
drawable.setColorFilter(this.a.D);
|
|
} else {
|
|
if (this.a.H) {
|
|
DrawableCompat.a(drawable, this.a.F);
|
|
}
|
|
if (this.a.I) {
|
|
DrawableCompat.a(drawable, this.a.G);
|
|
}
|
|
}
|
|
drawable.setVisible(isVisible(), true);
|
|
drawable.setDither(this.a.x);
|
|
drawable.setState(getState());
|
|
drawable.setLevel(getLevel());
|
|
drawable.setBounds(getBounds());
|
|
if (Build.VERSION.SDK_INT >= 23) {
|
|
drawable.setLayoutDirection(getLayoutDirection());
|
|
}
|
|
if (Build.VERSION.SDK_INT >= 19) {
|
|
drawable.setAutoMirrored(this.a.C);
|
|
}
|
|
Rect rect = this.b;
|
|
if (Build.VERSION.SDK_INT >= 21 && rect != null) {
|
|
drawable.setHotspotBounds(rect.left, rect.top, rect.right, rect.bottom);
|
|
}
|
|
} finally {
|
|
drawable.setCallback(this.l.a());
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:11:0x003f */
|
|
/* JADX WARN: Removed duplicated region for block: B:18:0x006a A[ADDED_TO_REGION] */
|
|
/* JADX WARN: Removed duplicated region for block: B:23:? A[ADDED_TO_REGION, RETURN, SYNTHETIC] */
|
|
/* JADX WARN: Removed duplicated region for block: B:25:0x0065 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct code enable 'Show inconsistent code' option in preferences
|
|
*/
|
|
void a(boolean r14) {
|
|
/*
|
|
r13 = this;
|
|
r0 = 1
|
|
r13.f = r0
|
|
long r1 = android.os.SystemClock.uptimeMillis()
|
|
android.graphics.drawable.Drawable r3 = r13.c
|
|
r4 = 255(0xff, double:1.26E-321)
|
|
r6 = 0
|
|
r7 = 0
|
|
if (r3 == 0) goto L38
|
|
long r9 = r13.j
|
|
int r11 = (r9 > r7 ? 1 : (r9 == r7 ? 0 : -1))
|
|
if (r11 == 0) goto L3a
|
|
int r11 = (r9 > r1 ? 1 : (r9 == r1 ? 0 : -1))
|
|
if (r11 > 0) goto L22
|
|
int r9 = r13.e
|
|
r3.setAlpha(r9)
|
|
r13.j = r7
|
|
goto L3a
|
|
L22:
|
|
long r9 = r9 - r1
|
|
long r9 = r9 * r4
|
|
int r10 = (int) r9
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r9 = r13.a
|
|
int r9 = r9.A
|
|
int r10 = r10 / r9
|
|
int r9 = 255 - r10
|
|
int r10 = r13.e
|
|
int r9 = r9 * r10
|
|
int r9 = r9 / 255
|
|
r3.setAlpha(r9)
|
|
r3 = 1
|
|
goto L3b
|
|
L38:
|
|
r13.j = r7
|
|
L3a:
|
|
r3 = 0
|
|
L3b:
|
|
android.graphics.drawable.Drawable r9 = r13.d
|
|
if (r9 == 0) goto L65
|
|
long r10 = r13.k
|
|
int r12 = (r10 > r7 ? 1 : (r10 == r7 ? 0 : -1))
|
|
if (r12 == 0) goto L67
|
|
int r12 = (r10 > r1 ? 1 : (r10 == r1 ? 0 : -1))
|
|
if (r12 > 0) goto L52
|
|
r9.setVisible(r6, r6)
|
|
r0 = 0
|
|
r13.d = r0
|
|
r13.k = r7
|
|
goto L67
|
|
L52:
|
|
long r10 = r10 - r1
|
|
long r10 = r10 * r4
|
|
int r3 = (int) r10
|
|
androidx.appcompat.graphics.drawable.DrawableContainer$DrawableContainerState r4 = r13.a
|
|
int r4 = r4.B
|
|
int r3 = r3 / r4
|
|
int r4 = r13.e
|
|
int r3 = r3 * r4
|
|
int r3 = r3 / 255
|
|
r9.setAlpha(r3)
|
|
goto L68
|
|
L65:
|
|
r13.k = r7
|
|
L67:
|
|
r0 = r3
|
|
L68:
|
|
if (r14 == 0) goto L74
|
|
if (r0 == 0) goto L74
|
|
java.lang.Runnable r14 = r13.i
|
|
r3 = 16
|
|
long r1 = r1 + r3
|
|
r13.scheduleSelf(r14, r1)
|
|
L74:
|
|
return
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.graphics.drawable.DrawableContainer.a(boolean):void");
|
|
}
|
|
|
|
final void a(Resources resources) {
|
|
this.a.a(resources);
|
|
}
|
|
|
|
protected void a(DrawableContainerState drawableContainerState) {
|
|
this.a = drawableContainerState;
|
|
int i = this.g;
|
|
if (i >= 0) {
|
|
this.c = drawableContainerState.a(i);
|
|
Drawable drawable = this.c;
|
|
if (drawable != null) {
|
|
a(drawable);
|
|
}
|
|
}
|
|
this.d = null;
|
|
}
|
|
|
|
static int a(Resources resources, int i) {
|
|
if (resources != null) {
|
|
i = resources.getDisplayMetrics().densityDpi;
|
|
}
|
|
if (i == 0) {
|
|
return 160;
|
|
}
|
|
return i;
|
|
}
|
|
}
|