BAM Crawford v6.14.1 - m0.java 源代码

package y1;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Typeface;
import android.graphics.drawable.Animatable;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class m0 extends Drawable implements Drawable.Callback, Animatable {

    private static final boolean f16697h0;

    private static final Executor f16698i0;
    String A;
    y1.b B;
    a1 C;
    private boolean D;
    private boolean E;
    private boolean F;
    private g2.c G;
    private int H;
    private boolean I;
    private boolean J;
    private boolean K;
    private y0 L;
    private boolean M;
    private final Matrix N;
    private Bitmap O;
    private Canvas P;
    private Rect Q;
    private RectF R;
    private Paint S;
    private Rect T;
    private Rect U;
    private RectF V;
    private RectF W;
    private Matrix X;
    private Matrix Y;
    private boolean Z;

    private y1.a f16699a0;

    private final ValueAnimator.AnimatorUpdateListener f16700b0;

    private final Semaphore f16701c0;

    private Handler f16702d0;

    private Runnable f16703e0;

    private final Runnable f16704f0;

    private float f16705g0;

    private k f16706p;

    private final k2.i f16707q;

    private boolean f16708r;

    private boolean f16709s;

    private boolean f16710t;

    private b f16711u;

    private final ArrayList f16712v;

    private c2.b f16713w;

    private String f16714x;

    private c2.a f16715y;

    private Map f16716z;

    interface a {
        void a(k kVar);
    }

    private enum b {
        NONE,
        PLAY,
        RESUME
    }

    static {
        f16697h0 = Build.VERSION.SDK_INT <= 25;
        f16698i0 = new ThreadPoolExecutor(0, 2, 35L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(), new k2.g());
    }

    public m0() {
        k2.i iVar = new k2.i();
        this.f16707q = iVar;
        this.f16708r = true;
        this.f16709s = false;
        this.f16710t = false;
        this.f16711u = b.NONE;
        this.f16712v = new ArrayList();
        this.E = false;
        this.F = true;
        this.H = 255;
        this.L = y0.AUTOMATIC;
        this.M = false;
        this.N = new Matrix();
        this.Z = false;
        ValueAnimator.AnimatorUpdateListener animatorUpdateListener = new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public final void onAnimationUpdate(ValueAnimator valueAnimator) {
                m0.this.g0(valueAnimator);
            }
        };
        this.f16700b0 = animatorUpdateListener;
        this.f16701c0 = new Semaphore(1);
        this.f16704f0 = new Runnable() {
            @Override
            public final void run() {
                m0.this.i0();
            }
        };
        this.f16705g0 = -3.4028235E38f;
        iVar.addUpdateListener(animatorUpdateListener);
    }

    private void B0(RectF rectF, float f10, float f11) {
        rectF.set(rectF.left * f10, rectF.top * f11, rectF.right * f10, rectF.bottom * f11);
    }

    private void D(int i10, int i11) {
        Bitmap bitmap = this.O;
        if (bitmap == null || bitmap.getWidth() < i10 || this.O.getHeight() < i11) {
            Bitmap createBitmap = Bitmap.createBitmap(i10, i11, Bitmap.Config.ARGB_8888);
            this.O = createBitmap;
            this.P.setBitmap(createBitmap);
            this.Z = true;
            return;
        }
        if (this.O.getWidth() > i10 || this.O.getHeight() > i11) {
            Bitmap createBitmap2 = Bitmap.createBitmap(this.O, 0, 0, i10, i11);
            this.O = createBitmap2;
            this.P.setBitmap(createBitmap2);
            this.Z = true;
        }
    }

    private void E() {
        if (this.P != null) {
            return;
        }
        this.P = new Canvas();
        this.W = new RectF();
        this.X = new Matrix();
        this.Y = new Matrix();
        this.Q = new Rect();
        this.R = new RectF();
        this.S = new z1.a();
        this.T = new Rect();
        this.U = new Rect();
        this.V = new RectF();
    }

    private Context K() {
        Drawable.Callback callback = getCallback();
        if (callback != null && (callback instanceof View)) {
            return ((View) callback).getContext();
        }
        return null;
    }

    private c2.a L() {
        if (getCallback() == null) {
            return null;
        }
        if (this.f16715y == null) {
            c2.a aVar = new c2.a(getCallback(), this.B);
            this.f16715y = aVar;
            String str = this.A;
            if (str != null) {
                aVar.c(str);
            }
        }
        return this.f16715y;
    }

    private c2.b N() {
        c2.b bVar = this.f16713w;
        if (bVar != null && !bVar.b(K())) {
            this.f16713w = null;
        }
        if (this.f16713w == null) {
            this.f16713w = new c2.b(getCallback(), this.f16714x, null, this.f16706p.j());
        }
        return this.f16713w;
    }

    private boolean b0() {
        Drawable.Callback callback = getCallback();
        if (!(callback instanceof View)) {
            return false;
        }
        if (((View) callback).getParent() instanceof ViewGroup) {
            return !((ViewGroup) r0).getClipChildren();
        }
        return false;
    }

    public void f0(d2.e eVar, Object obj, l2.c cVar, k kVar) {
        r(eVar, obj, cVar);
    }

    public void g0(ValueAnimator valueAnimator) {
        if (G()) {
            invalidateSelf();
            return;
        }
        g2.c cVar = this.G;
        if (cVar != null) {
            cVar.M(this.f16707q.j());
        }
    }

    public void h0() {
        Drawable.Callback callback = getCallback();
        if (callback != null) {
            callback.invalidateDrawable(this);
        }
    }

    private boolean h1() {
        k kVar = this.f16706p;
        if (kVar == null) {
            return false;
        }
        float f10 = this.f16705g0;
        float j10 = this.f16707q.j();
        this.f16705g0 = j10;
        return Math.abs(j10 - f10) * kVar.d() >= 50.0f;
    }

    public void i0() {
        g2.c cVar = this.G;
        if (cVar == null) {
            return;
        }
        try {
            this.f16701c0.acquire();
            cVar.M(this.f16707q.j());
            if (f16697h0 && this.Z) {
                if (this.f16702d0 == null) {
                    this.f16702d0 = new Handler(Looper.getMainLooper());
                    this.f16703e0 = new Runnable() {
                        @Override
                        public final void run() {
                            m0.this.h0();
                        }
                    };
                }
                this.f16702d0.post(this.f16703e0);
            }
        } catch (InterruptedException unused) {
        } catch (Throwable th) {
            this.f16701c0.release();
            throw th;
        }
        this.f16701c0.release();
    }

    public void j0(k kVar) {
        w0();
    }

    public void k0(k kVar) {
        z0();
    }

    public void l0(int i10, k kVar) {
        J0(i10);
    }

    public void m0(String str, k kVar) {
        P0(str);
    }

    public void n0(int i10, k kVar) {
        O0(i10);
    }

    public void o0(float f10, k kVar) {
        Q0(f10);
    }

    public void p0(String str, k kVar) {
        S0(str);
    }

    public void q0(int i10, int i11, k kVar) {
        R0(i10, i11);
    }

    public void r0(int i10, k kVar) {
        T0(i10);
    }

    private boolean s() {
        return this.f16708r || this.f16709s;
    }

    public void s0(String str, k kVar) {
        U0(str);
    }

    private void t() {
        k kVar = this.f16706p;
        if (kVar == null) {
            return;
        }
        g2.c cVar = new g2.c(this, i2.v.b(kVar), kVar.k(), kVar);
        this.G = cVar;
        if (this.J) {
            cVar.K(true);
        }
        this.G.Q(this.F);
    }

    public void t0(float f10, k kVar) {
        V0(f10);
    }

    public void u0(float f10, k kVar) {
        Y0(f10);
    }

    private void w() {
        k kVar = this.f16706p;
        if (kVar == null) {
            return;
        }
        this.M = this.L.useSoftwareRendering(Build.VERSION.SDK_INT, kVar.q(), kVar.m());
    }

    private void x(Rect rect, RectF rectF) {
        rectF.set(rect.left, rect.top, rect.right, rect.bottom);
    }

    private void x0(Canvas canvas, g2.c cVar) {
        if (this.f16706p == null || cVar == null) {
            return;
        }
        E();
        canvas.getMatrix(this.X);
        canvas.getClipBounds(this.Q);
        x(this.Q, this.R);
        this.X.mapRect(this.R);
        y(this.R, this.Q);
        if (this.F) {
            this.W.set(0.0f, 0.0f, getIntrinsicWidth(), getIntrinsicHeight());
        } else {
            cVar.d(this.W, null, false);
        }
        this.X.mapRect(this.W);
        Rect bounds = getBounds();
        float width = bounds.width() / getIntrinsicWidth();
        float height = bounds.height() / getIntrinsicHeight();
        B0(this.W, width, height);
        if (!b0()) {
            RectF rectF = this.W;
            Rect rect = this.Q;
            rectF.intersect(rect.left, rect.top, rect.right, rect.bottom);
        }
        int ceil = (int) Math.ceil(this.W.width());
        int ceil2 = (int) Math.ceil(this.W.height());
        if (ceil <= 0 || ceil2 <= 0) {
            return;
        }
        D(ceil, ceil2);
        if (this.Z) {
            this.N.set(this.X);
            this.N.preScale(width, height);
            Matrix matrix = this.N;
            RectF rectF2 = this.W;
            matrix.postTranslate(-rectF2.left, -rectF2.top);
            this.O.eraseColor(0);
            cVar.g(this.P, this.N, this.H);
            this.X.invert(this.Y);
            this.Y.mapRect(this.V, this.W);
            y(this.V, this.U);
        }
        this.T.set(0, 0, ceil, ceil2);
        canvas.drawBitmap(this.O, this.T, this.U, this.S);
    }

    private void y(RectF rectF, Rect rect) {
        rect.set((int) Math.floor(rectF.left), (int) Math.floor(rectF.top), (int) Math.ceil(rectF.right), (int) Math.ceil(rectF.bottom));
    }

    private void z(Canvas canvas) {
        g2.c cVar = this.G;
        k kVar = this.f16706p;
        if (cVar == null || kVar == null) {
            return;
        }
        this.N.reset();
        if (!getBounds().isEmpty()) {
            this.N.preScale(r2.width() / kVar.b().width(), r2.height() / kVar.b().height());
            this.N.preTranslate(r2.left, r2.top);
        }
        cVar.g(canvas, this.N, this.H);
    }

    public void A(boolean z10) {
        if (this.D == z10) {
            return;
        }
        this.D = z10;
        if (this.f16706p != null) {
            t();
        }
    }

    public void A0() {
        this.f16707q.w();
    }

    public boolean B() {
        return this.D;
    }

    public void C() {
        this.f16712v.clear();
        this.f16707q.i();
        if (isVisible()) {
            return;
        }
        this.f16711u = b.NONE;
    }

    public void C0(boolean z10) {
        this.K = z10;
    }

    public void D0(y1.a aVar) {
        this.f16699a0 = aVar;
    }

    public void E0(boolean z10) {
        if (z10 != this.F) {
            this.F = z10;
            g2.c cVar = this.G;
            if (cVar != null) {
                cVar.Q(z10);
            }
            invalidateSelf();
        }
    }

    public y1.a F() {
        y1.a aVar = this.f16699a0;
        return aVar != null ? aVar : e.d();
    }

    public boolean F0(k kVar) {
        if (this.f16706p == kVar) {
            return false;
        }
        this.Z = true;
        v();
        this.f16706p = kVar;
        t();
        this.f16707q.x(kVar);
        Y0(this.f16707q.getAnimatedFraction());
        Iterator it = new ArrayList(this.f16712v).iterator();
        while (it.hasNext()) {
            a aVar = (a) it.next();
            if (aVar != null) {
                aVar.a(kVar);
            }
            it.remove();
        }
        this.f16712v.clear();
        kVar.v(this.I);
        w();
        Drawable.Callback callback = getCallback();
        if (callback instanceof ImageView) {
            ImageView imageView = (ImageView) callback;
            imageView.setImageDrawable(null);
            imageView.setImageDrawable(this);
        }
        return true;
    }

    public boolean G() {
        return F() == y1.a.ENABLED;
    }

    public void G0(String str) {
        this.A = str;
        c2.a L = L();
        if (L != null) {
            L.c(str);
        }
    }

    public Bitmap H(String str) {
        c2.b N = N();
        if (N != null) {
            return N.a(str);
        }
        return null;
    }

    public void H0(y1.b bVar) {
        this.B = bVar;
        c2.a aVar = this.f16715y;
        if (aVar != null) {
            aVar.d(bVar);
        }
    }

    public boolean I() {
        return this.F;
    }

    public void I0(Map map) {
        if (map == this.f16716z) {
            return;
        }
        this.f16716z = map;
        invalidateSelf();
    }

    public k J() {
        return this.f16706p;
    }

    public void J0(final int i10) {
        if (this.f16706p == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.l0(i10, kVar);
                }
            });
        } else {
            this.f16707q.z(i10);
        }
    }

    public void K0(boolean z10) {
        this.f16709s = z10;
    }

    public void L0(c cVar) {
        c2.b bVar = this.f16713w;
        if (bVar != null) {
            bVar.d(cVar);
        }
    }

    public int M() {
        return (int) this.f16707q.k();
    }

    public void M0(String str) {
        this.f16714x = str;
    }

    public void N0(boolean z10) {
        this.E = z10;
    }

    public String O() {
        return this.f16714x;
    }

    public void O0(final int i10) {
        if (this.f16706p == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.n0(i10, kVar);
                }
            });
        } else {
            this.f16707q.A(i10 + 0.99f);
        }
    }

    public n0 P(String str) {
        k kVar = this.f16706p;
        if (kVar == null) {
            return null;
        }
        return (n0) kVar.j().get(str);
    }

    public void P0(final String str) {
        k kVar = this.f16706p;
        if (kVar == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar2) {
                    m0.this.m0(str, kVar2);
                }
            });
            return;
        }
        d2.h l10 = kVar.l(str);
        if (l10 != null) {
            O0((int) (l10.f8813b + l10.f8814c));
            return;
        }
        throw new IllegalArgumentException("Cannot find marker with name " + str + ".");
    }

    public boolean Q() {
        return this.E;
    }

    public void Q0(final float f10) {
        k kVar = this.f16706p;
        if (kVar == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar2) {
                    m0.this.o0(f10, kVar2);
                }
            });
        } else {
            this.f16707q.A(k2.k.i(kVar.p(), this.f16706p.f(), f10));
        }
    }

    public float R() {
        return this.f16707q.m();
    }

    public void R0(final int i10, final int i11) {
        if (this.f16706p == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.q0(i10, i11, kVar);
                }
            });
        } else {
            this.f16707q.B(i10, i11 + 0.99f);
        }
    }

    public float S() {
        return this.f16707q.n();
    }

    public void S0(final String str) {
        k kVar = this.f16706p;
        if (kVar == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar2) {
                    m0.this.p0(str, kVar2);
                }
            });
            return;
        }
        d2.h l10 = kVar.l(str);
        if (l10 != null) {
            int i10 = (int) l10.f8813b;
            R0(i10, ((int) l10.f8814c) + i10);
        } else {
            throw new IllegalArgumentException("Cannot find marker with name " + str + ".");
        }
    }

    public v0 T() {
        k kVar = this.f16706p;
        if (kVar != null) {
            return kVar.n();
        }
        return null;
    }

    public void T0(final int i10) {
        if (this.f16706p == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.r0(i10, kVar);
                }
            });
        } else {
            this.f16707q.C(i10);
        }
    }

    public float U() {
        return this.f16707q.j();
    }

    public void U0(final String str) {
        k kVar = this.f16706p;
        if (kVar == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar2) {
                    m0.this.s0(str, kVar2);
                }
            });
            return;
        }
        d2.h l10 = kVar.l(str);
        if (l10 != null) {
            T0((int) l10.f8813b);
            return;
        }
        throw new IllegalArgumentException("Cannot find marker with name " + str + ".");
    }

    public y0 V() {
        return this.M ? y0.SOFTWARE : y0.HARDWARE;
    }

    public void V0(final float f10) {
        k kVar = this.f16706p;
        if (kVar == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar2) {
                    m0.this.t0(f10, kVar2);
                }
            });
        } else {
            T0((int) k2.k.i(kVar.p(), this.f16706p.f(), f10));
        }
    }

    public int W() {
        return this.f16707q.getRepeatCount();
    }

    public void W0(boolean z10) {
        if (this.J == z10) {
            return;
        }
        this.J = z10;
        g2.c cVar = this.G;
        if (cVar != null) {
            cVar.K(z10);
        }
    }

    public int X() {
        return this.f16707q.getRepeatMode();
    }

    public void X0(boolean z10) {
        this.I = z10;
        k kVar = this.f16706p;
        if (kVar != null) {
            kVar.v(z10);
        }
    }

    public float Y() {
        return this.f16707q.o();
    }

    public void Y0(final float f10) {
        if (this.f16706p == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.u0(f10, kVar);
                }
            });
            return;
        }
        e.b("Drawable#setProgress");
        this.f16707q.z(this.f16706p.h(f10));
        e.c("Drawable#setProgress");
    }

    public a1 Z() {
        return this.C;
    }

    public void Z0(y0 y0Var) {
        this.L = y0Var;
        w();
    }

    public Typeface a0(d2.c cVar) {
        Map map = this.f16716z;
        if (map != null) {
            String a10 = cVar.a();
            if (map.containsKey(a10)) {
                return (Typeface) map.get(a10);
            }
            String b10 = cVar.b();
            if (map.containsKey(b10)) {
                return (Typeface) map.get(b10);
            }
            String str = cVar.a() + "-" + cVar.c();
            if (map.containsKey(str)) {
                return (Typeface) map.get(str);
            }
        }
        c2.a L = L();
        if (L != null) {
            return L.b(cVar);
        }
        return null;
    }

    public void a1(int i10) {
        this.f16707q.setRepeatCount(i10);
    }

    public void b1(int i10) {
        this.f16707q.setRepeatMode(i10);
    }

    public boolean c0() {
        k2.i iVar = this.f16707q;
        if (iVar == null) {
            return false;
        }
        return iVar.isRunning();
    }

    public void c1(boolean z10) {
        this.f16710t = z10;
    }

    boolean d0() {
        if (isVisible()) {
            return this.f16707q.isRunning();
        }
        b bVar = this.f16711u;
        return bVar == b.PLAY || bVar == b.RESUME;
    }

    public void d1(float f10) {
        this.f16707q.D(f10);
    }

    @Override
    public void draw(Canvas canvas) {
        g2.c cVar = this.G;
        if (cVar == null) {
            return;
        }
        boolean G = G();
        if (G) {
            try {
                this.f16701c0.acquire();
            } catch (InterruptedException unused) {
                e.c("Drawable#draw");
                if (!G) {
                    return;
                }
                this.f16701c0.release();
                if (cVar.P() == this.f16707q.j()) {
                    return;
                }
            } catch (Throwable th) {
                e.c("Drawable#draw");
                if (G) {
                    this.f16701c0.release();
                    if (cVar.P() != this.f16707q.j()) {
                        f16698i0.execute(this.f16704f0);
                    }
                }
                throw th;
            }
        }
        e.b("Drawable#draw");
        if (G && h1()) {
            Y0(this.f16707q.j());
        }
        if (this.f16710t) {
            try {
                if (this.M) {
                    x0(canvas, cVar);
                } else {
                    z(canvas);
                }
            } catch (Throwable th2) {
                k2.f.b("Lottie crashed in draw!", th2);
            }
        } else if (this.M) {
            x0(canvas, cVar);
        } else {
            z(canvas);
        }
        this.Z = false;
        e.c("Drawable#draw");
        if (G) {
            this.f16701c0.release();
            if (cVar.P() == this.f16707q.j()) {
                return;
            }
            f16698i0.execute(this.f16704f0);
        }
    }

    public boolean e0() {
        return this.K;
    }

    public void e1(Boolean bool) {
        this.f16708r = bool.booleanValue();
    }

    public void f1(a1 a1Var) {
        this.C = a1Var;
    }

    public void g1(boolean z10) {
        this.f16707q.E(z10);
    }

    @Override
    public int getAlpha() {
        return this.H;
    }

    @Override
    public int getIntrinsicHeight() {
        k kVar = this.f16706p;
        if (kVar == null) {
            return -1;
        }
        return kVar.b().height();
    }

    @Override
    public int getIntrinsicWidth() {
        k kVar = this.f16706p;
        if (kVar == null) {
            return -1;
        }
        return kVar.b().width();
    }

    @Override
    public int getOpacity() {
        return -3;
    }

    public boolean i1() {
        return this.f16716z == null && this.C == null && this.f16706p.c().l() > 0;
    }

    @Override
    public void invalidateDrawable(Drawable drawable) {
        Drawable.Callback callback = getCallback();
        if (callback == null) {
            return;
        }
        callback.invalidateDrawable(this);
    }

    @Override
    public void invalidateSelf() {
        Drawable.Callback callback;
        if (this.Z) {
            return;
        }
        this.Z = true;
        if ((!f16697h0 || Looper.getMainLooper() == Looper.myLooper()) && (callback = getCallback()) != null) {
            callback.invalidateDrawable(this);
        }
    }

    @Override
    public boolean isRunning() {
        return c0();
    }

    public void q(Animator.AnimatorListener animatorListener) {
        this.f16707q.addListener(animatorListener);
    }

    public void r(final d2.e eVar, final Object obj, final l2.c cVar) {
        g2.c cVar2 = this.G;
        if (cVar2 == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.f0(eVar, obj, cVar, kVar);
                }
            });
            return;
        }
        boolean z10 = true;
        if (eVar == d2.e.f8807c) {
            cVar2.f(obj, cVar);
        } else if (eVar.d() != null) {
            eVar.d().f(obj, cVar);
        } else {
            List y02 = y0(eVar);
            for (int i10 = 0; i10 < y02.size(); i10++) {
                ((d2.e) y02.get(i10)).d().f(obj, cVar);
            }
            z10 = true ^ y02.isEmpty();
        }
        if (z10) {
            invalidateSelf();
            if (obj == r0.E) {
                Y0(U());
            }
        }
    }

    @Override
    public void scheduleDrawable(Drawable drawable, Runnable runnable, long j10) {
        Drawable.Callback callback = getCallback();
        if (callback == null) {
            return;
        }
        callback.scheduleDrawable(this, runnable, j10);
    }

    @Override
    public void setAlpha(int i10) {
        this.H = i10;
        invalidateSelf();
    }

    @Override
    public void setColorFilter(ColorFilter colorFilter) {
        k2.f.c("Use addColorFilter instead.");
    }

    @Override
    public boolean setVisible(boolean z10, boolean z11) {
        boolean z12 = !isVisible();
        boolean visible = super.setVisible(z10, z11);
        if (z10) {
            b bVar = this.f16711u;
            if (bVar == b.PLAY) {
                w0();
            } else if (bVar == b.RESUME) {
                z0();
            }
        } else if (this.f16707q.isRunning()) {
            v0();
            this.f16711u = b.RESUME;
        } else if (!z12) {
            this.f16711u = b.NONE;
        }
        return visible;
    }

    @Override
    public void start() {
        Drawable.Callback callback = getCallback();
        if ((callback instanceof View) && ((View) callback).isInEditMode()) {
            return;
        }
        w0();
    }

    @Override
    public void stop() {
        C();
    }

    public void u() {
        this.f16712v.clear();
        this.f16707q.cancel();
        if (isVisible()) {
            return;
        }
        this.f16711u = b.NONE;
    }

    @Override
    public void unscheduleDrawable(Drawable drawable, Runnable runnable) {
        Drawable.Callback callback = getCallback();
        if (callback == null) {
            return;
        }
        callback.unscheduleDrawable(this, runnable);
    }

    public void v() {
        if (this.f16707q.isRunning()) {
            this.f16707q.cancel();
            if (!isVisible()) {
                this.f16711u = b.NONE;
            }
        }
        this.f16706p = null;
        this.G = null;
        this.f16713w = null;
        this.f16705g0 = -3.4028235E38f;
        this.f16707q.h();
        invalidateSelf();
    }

    public void v0() {
        this.f16712v.clear();
        this.f16707q.q();
        if (isVisible()) {
            return;
        }
        this.f16711u = b.NONE;
    }

    public void w0() {
        if (this.G == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.j0(kVar);
                }
            });
            return;
        }
        w();
        if (s() || W() == 0) {
            if (isVisible()) {
                this.f16707q.r();
                this.f16711u = b.NONE;
            } else {
                this.f16711u = b.PLAY;
            }
        }
        if (s()) {
            return;
        }
        J0((int) (Y() < 0.0f ? S() : R()));
        this.f16707q.i();
        if (isVisible()) {
            return;
        }
        this.f16711u = b.NONE;
    }

    public List y0(d2.e eVar) {
        if (this.G == null) {
            k2.f.c("Cannot resolve KeyPath. Composition is not set yet.");
            return Collections.emptyList();
        }
        ArrayList arrayList = new ArrayList();
        this.G.h(eVar, 0, arrayList, new d2.e(new String[0]));
        return arrayList;
    }

    public void z0() {
        if (this.G == null) {
            this.f16712v.add(new a() {
                @Override
                public final void a(k kVar) {
                    m0.this.k0(kVar);
                }
            });
            return;
        }
        w();
        if (s() || W() == 0) {
            if (isVisible()) {
                this.f16707q.v();
                this.f16711u = b.NONE;
            } else {
                this.f16711u = b.RESUME;
            }
        }
        if (s()) {
            return;
        }
        J0((int) (Y() < 0.0f ? S() : R()));
        this.f16707q.i();
        if (isVisible()) {
            return;
        }
        this.f16711u = b.NONE;
    }
}