零界绘 v1.0.2 - i.java 源代码

package com.bytedance.adsdk.lottie;

import android.animation.Animator;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
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.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.widget.ImageView;
import com.bytedance.adsdk.lottie.p.u;
import com.bytedance.component.sdk.annotation.FloatRange;
import com.bytedance.component.sdk.annotation.IntRange;
import com.bytedance.component.sdk.annotation.MainThread;
import com.bytedance.component.sdk.annotation.RestrictTo;
import com.bytedance.sdk.openadsdk.TTAdConstant;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class i extends Drawable implements Animatable, Drawable.Callback {
    public k ca;
    public lu cl;
    public Paint d;
    public String da;
    public boolean dw;
    public Canvas e;
    public LottieAnimationView es;
    public boolean g;
    public p gd;
    public Map<String, Typeface> hr;
    public RectF j;
    public Matrix je;
    public RectF js;
    public com.bytedance.adsdk.lottie.cl.cl jv;
    public com.bytedance.adsdk.lottie.model.layer.p l;
    public l lu;
    public Bitmap n;
    public Rect ns;
    public h p;
    public Rect qx;
    public Rect r;
    public com.bytedance.adsdk.lottie.cl.y rh;
    public boolean u;
    public boolean v;
    public Matrix ws;
    public RectF x;
    public String y;
    public final com.bytedance.adsdk.lottie.io.h io = new com.bytedance.adsdk.lottie.io.h();
    public boolean h = true;
    public boolean st = false;
    public boolean i = false;
    public cl a = cl.NONE;
    public final ArrayList<y> q = new ArrayList<>();
    public final ValueAnimator.AnimatorUpdateListener m = new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {
            if (i.this.l != null) {
                i.this.l.y(i.this.io.h());
            }
        }
    };
    public boolean oe = false;
    public boolean b = true;
    public int k = 255;
    public b c = b.AUTOMATIC;
    public boolean yv = false;
    public final Matrix aq = new Matrix();
    public boolean uw = false;

    public enum cl {
        NONE,
        PLAY,
        RESUME
    }

    public interface y {
        void y(h hVar);
    }

    public i(LottieAnimationView lottieAnimationView) {
        this.es = lottieAnimationView;
        this.io.addUpdateListener(this.m);
    }

    private void d() {
        h hVar = this.p;
        if (hVar == null) {
            return;
        }
        this.yv = this.c.y(Build.VERSION.SDK_INT, hVar.y(), hVar.cl());
    }

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

    private void js() {
        if (this.e != null) {
            return;
        }
        this.e = new Canvas();
        this.js = new RectF();
        this.ws = new Matrix();
        this.je = new Matrix();
        this.r = new Rect();
        this.j = new RectF();
        this.d = new com.bytedance.adsdk.lottie.y.y();
        this.qx = new Rect();
        this.ns = new Rect();
        this.x = new RectF();
    }

    private com.bytedance.adsdk.lottie.cl.cl ns() {
        com.bytedance.adsdk.lottie.cl.cl clVar = this.jv;
        if (clVar != null && !clVar.y(getContext())) {
            this.jv = null;
        }
        if (this.jv == null) {
            this.jv = new com.bytedance.adsdk.lottie.cl.cl(getCallback(), this.da, this.gd, this.p.dw());
        }
        return this.jv;
    }

    private boolean qx() {
        return this.h || this.st;
    }

    private boolean ws() {
        Drawable.Callback callback = getCallback();
        if (!(callback instanceof View)) {
            return false;
        }
        ViewParent parent = ((View) callback).getParent();
        return Build.VERSION.SDK_INT >= 18 && (parent instanceof ViewGroup) && !((ViewGroup) parent).getClipChildren();
    }

    private com.bytedance.adsdk.lottie.cl.y x() {
        if (getCallback() == null) {
            return null;
        }
        if (this.rh == null) {
            com.bytedance.adsdk.lottie.cl.y yVar = new com.bytedance.adsdk.lottie.cl.y(getCallback(), this.cl);
            this.rh = yVar;
            String str = this.y;
            if (str != null) {
                yVar.y(str);
            }
        }
        return this.rh;
    }

    public oe a() {
        h hVar = this.p;
        if (hVar != null) {
            return hVar.lu();
        }
        return null;
    }

    public h aq() {
        return this.p;
    }

    public void b() {
        this.io.removeAllListeners();
    }

    public l c() {
        return this.lu;
    }

    @MainThread
    public void da() {
        this.q.clear();
        this.io.jv();
        if (isVisible()) {
            return;
        }
        this.a = cl.NONE;
    }

    @Override
    public void draw(Canvas canvas) {
        io.y("Drawable#draw");
        try {
            if (this.yv) {
                y(canvas, this.l);
            } else {
                y(canvas);
            }
        } catch (Throwable th) {
            com.bytedance.adsdk.lottie.io.io.cl("Lottie crashed in draw!", th);
        }
        this.uw = false;
        io.cl("Drawable#draw");
    }

    public float dw() {
        return this.io.q();
    }

    public void e() {
        this.q.clear();
        this.io.da();
        if (isVisible()) {
            return;
        }
        this.a = cl.NONE;
    }

    public boolean g() {
        com.bytedance.adsdk.lottie.io.h hVar = this.io;
        if (hVar == null) {
            return false;
        }
        return hVar.isRunning();
    }

    @MainThread
    public void gd() {
        if (this.l == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.gd();
                }
            });
            return;
        }
        d();
        if (qx() || u() == 0) {
            if (isVisible()) {
                this.io.gd();
                this.a = cl.NONE;
            } else {
                this.a = cl.RESUME;
            }
        }
        if (qx()) {
            return;
        }
        lu((int) (dw() < TTAdConstant.ASPECT_CORNER_RADIUS_DEFAULT ? rh() : hr()));
        this.io.jv();
        if (isVisible()) {
            return;
        }
        this.a = cl.NONE;
    }

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

    @Override
    public int getIntrinsicHeight() {
        h hVar = this.p;
        if (hVar == null) {
            return -1;
        }
        return hVar.p().height();
    }

    @Override
    public int getIntrinsicWidth() {
        h hVar = this.p;
        if (hVar == null) {
            return -1;
        }
        return hVar.p().width();
    }

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

    public boolean h() {
        return this.oe;
    }

    public float hr() {
        return this.io.hr();
    }

    public boolean i() {
        return this.yv;
    }

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

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

    public String io() {
        return this.da;
    }

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

    public RectF j() {
        return this.js;
    }

    @MainThread
    public void jv() {
        if (this.l == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.jv();
                }
            });
            return;
        }
        d();
        if (qx() || u() == 0) {
            if (isVisible()) {
                this.io.m();
                this.a = cl.NONE;
            } else {
                this.a = cl.PLAY;
            }
        }
        if (qx()) {
            return;
        }
        lu((int) (dw() < TTAdConstant.ASPECT_CORNER_RADIUS_DEFAULT ? rh() : hr()));
        this.io.jv();
        if (isVisible()) {
            return;
        }
        this.a = cl.NONE;
    }

    @SuppressLint({"WrongConstant"})
    public int k() {
        return this.io.getRepeatMode();
    }

    public int l() {
        return (int) this.io.st();
    }

    public com.bytedance.adsdk.lottie.model.layer.p lu() {
        return this.l;
    }

    public void m() {
        if (this.io.isRunning()) {
            this.io.cancel();
            if (!isVisible()) {
                this.a = cl.NONE;
            }
        }
        this.p = null;
        com.bytedance.adsdk.lottie.model.layer.p pVar = this.l;
        if (pVar != null) {
            y(pVar);
        }
        this.l = null;
        this.jv = null;
        this.io.i();
        invalidateSelf();
    }

    public void n() {
        this.q.clear();
        this.io.cancel();
        if (isVisible()) {
            return;
        }
        this.a = cl.NONE;
    }

    public void oe() {
        this.io.removeAllUpdateListeners();
        this.io.addUpdateListener(this.m);
    }

    public boolean p() {
        return this.b;
    }

    public boolean q() {
        return this.v;
    }

    @FloatRange(from = 0.0d, to = 1.0d)
    public float r() {
        return this.io.h();
    }

    public float rh() {
        return this.io.rh();
    }

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

    @Override
    public void setAlpha(@IntRange(from = 0, to = 255) int i) {
        this.k = i;
        invalidateSelf();
    }

    @Override
    public void setColorFilter(ColorFilter colorFilter) {
        com.bytedance.adsdk.lottie.io.io.cl("Use addColorFilter instead.");
    }

    @Override
    public boolean setVisible(boolean z, boolean z2) {
        boolean z3 = !isVisible();
        boolean visible = super.setVisible(z, z2);
        if (z) {
            cl clVar = this.a;
            if (clVar == cl.PLAY) {
                jv();
            } else if (clVar == cl.RESUME) {
                gd();
            }
        } else if (this.io.isRunning()) {
            e();
            this.a = cl.RESUME;
        } else if (!z3) {
            this.a = cl.NONE;
        }
        return visible;
    }

    public b st() {
        return this.yv ? b.SOFTWARE : b.HARDWARE;
    }

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

    @Override
    @MainThread
    public void stop() {
        da();
    }

    public int u() {
        return this.io.getRepeatCount();
    }

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

    public boolean v() {
        if (isVisible()) {
            return this.io.isRunning();
        }
        cl clVar = this.a;
        return clVar == cl.PLAY || clVar == cl.RESUME;
    }

    public boolean yv() {
        return this.hr == null && this.lu == null && this.p.rh().size() > 0;
    }

    public LottieAnimationView cl() {
        return this.es;
    }

    public void h(boolean z) {
        this.i = z;
    }

    public void i(boolean z) {
        this.io.lu(z);
    }

    public void io(boolean z) {
        this.v = z;
    }

    public void lu(boolean z) {
        this.u = z;
        h hVar = this.p;
        if (hVar != null) {
            hVar.cl(z);
        }
    }

    public void p(boolean z) {
        if (this.g == z) {
            return;
        }
        this.g = z;
        com.bytedance.adsdk.lottie.model.layer.p pVar = this.l;
        if (pVar != null) {
            pVar.y(z);
        }
    }

    public void st(boolean z) {
        this.st = z;
    }

    public void y(k kVar) {
        this.ca = kVar;
    }

    public void cl(boolean z) {
        this.oe = z;
    }

    public a h(String str) {
        h hVar = this.p;
        if (hVar == null) {
            return null;
        }
        return hVar.dw().get(str);
    }

    public void io(int i) {
        this.io.setRepeatCount(i);
    }

    public void st(String str) {
        this.y = str;
        com.bytedance.adsdk.lottie.cl.y x = x();
        if (x != null) {
            x.y(str);
        }
    }

    public k y() {
        return this.ca;
    }

    public void cl(final int i) {
        if (this.p == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.cl(i);
                }
            });
        } else {
            this.io.cl(i + 0.99f);
        }
    }

    public Bitmap io(String str) {
        com.bytedance.adsdk.lottie.cl.cl ns = ns();
        if (ns != null) {
            return ns.y(str);
        }
        return null;
    }

    public void y(boolean z, Context context) {
        if (this.dw == z) {
            return;
        }
        if (Build.VERSION.SDK_INT < 19) {
            com.bytedance.adsdk.lottie.io.io.cl("Merge paths are not supported pre-Kit Kat.");
            return;
        }
        this.dw = z;
        if (this.p != null) {
            y(context);
        }
    }

    public void lu(final String str) {
        h hVar = this.p;
        if (hVar == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar2) {
                    i.this.lu(str);
                }
            });
            return;
        }
        com.bytedance.adsdk.lottie.model.h lu = hVar.lu(str);
        if (lu != null) {
            cl((int) (lu.y + lu.cl));
            return;
        }
        throw new IllegalArgumentException("Cannot find marker with name " + str + ".");
    }

    public void p(final String str) {
        h hVar = this.p;
        if (hVar == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar2) {
                    i.this.p(str);
                }
            });
            return;
        }
        com.bytedance.adsdk.lottie.model.h lu = hVar.lu(str);
        if (lu != null) {
            int i = (int) lu.y;
            y(i, ((int) lu.cl) + i);
        } else {
            throw new IllegalArgumentException("Cannot find marker with name " + str + ".");
        }
    }

    public void cl(@FloatRange(from = 0.0d, to = 1.0d) final float f2) {
        h hVar = this.p;
        if (hVar == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar2) {
                    i.this.cl(f2);
                }
            });
        } else {
            this.io.cl(com.bytedance.adsdk.lottie.io.i.y(hVar.h(), this.p.st(), f2));
        }
    }

    public void cl(final String str) {
        h hVar = this.p;
        if (hVar == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar2) {
                    i.this.cl(str);
                }
            });
            return;
        }
        com.bytedance.adsdk.lottie.model.h lu = hVar.lu(str);
        if (lu != null) {
            y((int) lu.y);
            return;
        }
        throw new IllegalArgumentException("Cannot find marker with name " + str + ".");
    }

    public void lu(float f2) {
        this.io.lu(f2);
    }

    public void y(boolean z) {
        if (z != this.b) {
            this.b = z;
            com.bytedance.adsdk.lottie.model.layer.p pVar = this.l;
            if (pVar != null) {
                pVar.cl(z);
            }
            invalidateSelf();
        }
    }

    public void lu(final int i) {
        if (this.p == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.lu(i);
                }
            });
        } else {
            this.io.y(i);
        }
    }

    public void p(@FloatRange(from = 0.0d, to = 1.0d) final float f2) {
        if (this.p == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.p(f2);
                }
            });
            return;
        }
        io.y("Drawable#setProgress");
        this.io.y(this.p.y(f2));
        io.cl("Drawable#setProgress");
    }

    public void cl(ValueAnimator.AnimatorUpdateListener animatorUpdateListener) {
        this.io.removeUpdateListener(animatorUpdateListener);
    }

    public void y(String str) {
        this.da = str;
    }

    public void cl(Animator.AnimatorListener animatorListener) {
        this.io.removeListener(animatorListener);
    }

    public boolean y(h hVar, Context context) {
        if (this.p == hVar) {
            return false;
        }
        this.uw = true;
        m();
        this.p = hVar;
        y(context);
        this.io.y(hVar);
        p(this.io.getAnimatedFraction());
        Iterator it = new ArrayList(this.q).iterator();
        while (it.hasNext()) {
            y yVar = (y) it.next();
            if (yVar != null) {
                yVar.y(hVar);
            }
            it.remove();
        }
        this.q.clear();
        hVar.cl(this.u);
        d();
        Drawable.Callback callback = getCallback();
        if (callback instanceof ImageView) {
            ImageView imageView = (ImageView) callback;
            imageView.setImageDrawable(null);
            imageView.setImageDrawable(this);
        }
        return true;
    }

    private void cl(int i, int i2) {
        Bitmap bitmap = this.n;
        if (bitmap != null && bitmap.getWidth() >= i && this.n.getHeight() >= i2) {
            if (this.n.getWidth() > i || this.n.getHeight() > i2) {
                Bitmap createBitmap = Bitmap.createBitmap(this.n, 0, 0, i, i2);
                this.n = createBitmap;
                this.e.setBitmap(createBitmap);
                this.uw = true;
                return;
            }
            return;
        }
        Bitmap createBitmap2 = Bitmap.createBitmap(i, i2, Bitmap.Config.ARGB_8888);
        this.n = createBitmap2;
        this.e.setBitmap(createBitmap2);
        this.uw = true;
    }

    public void p(int i) {
        this.io.setRepeatMode(i);
    }

    public void y(b bVar) {
        this.c = bVar;
        d();
    }

    private void y(Context context) {
        h hVar = this.p;
        if (hVar == null) {
            return;
        }
        com.bytedance.adsdk.lottie.model.layer.p pVar = this.l;
        if (pVar != null) {
            y(pVar);
        }
        com.bytedance.adsdk.lottie.model.layer.p pVar2 = new com.bytedance.adsdk.lottie.model.layer.p(this, u.y(hVar), hVar.gd(), hVar, context);
        this.l = pVar2;
        if (this.g) {
            pVar2.y(true);
        }
        this.l.cl(this.b);
    }

    private void y(com.bytedance.adsdk.lottie.model.layer.p pVar) {
        if (pVar != null) {
            pVar.lu();
            List<com.bytedance.adsdk.lottie.model.layer.lu> gd = pVar.gd();
            if (gd != null) {
                for (com.bytedance.adsdk.lottie.model.layer.lu luVar : gd) {
                    if (luVar instanceof com.bytedance.adsdk.lottie.model.layer.p) {
                        y((com.bytedance.adsdk.lottie.model.layer.p) luVar);
                    } else if (luVar != null) {
                        luVar.lu();
                    }
                }
            }
        }
    }

    public void y(final int i) {
        if (this.p == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.y(i);
                }
            });
        } else {
            this.io.y(i);
        }
    }

    public void y(final float f2) {
        h hVar = this.p;
        if (hVar == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar2) {
                    i.this.y(f2);
                }
            });
        } else {
            y((int) com.bytedance.adsdk.lottie.io.i.y(hVar.h(), this.p.st(), f2));
        }
    }

    public void y(final int i, final int i2) {
        if (this.p == null) {
            this.q.add(new y() {
                @Override
                public void y(h hVar) {
                    i.this.y(i, i2);
                }
            });
        } else {
            this.io.y(i, i2 + 0.99f);
        }
    }

    public void y(ValueAnimator.AnimatorUpdateListener animatorUpdateListener) {
        this.io.addUpdateListener(animatorUpdateListener);
    }

    public void y(Animator.AnimatorListener animatorListener) {
        this.io.addListener(animatorListener);
    }

    public void y(Boolean bool) {
        this.h = bool.booleanValue();
    }

    public void y(p pVar) {
        this.gd = pVar;
        com.bytedance.adsdk.lottie.cl.cl clVar = this.jv;
        if (clVar != null) {
            clVar.y(pVar);
        }
    }

    public void y(lu luVar) {
        this.cl = luVar;
        com.bytedance.adsdk.lottie.cl.y yVar = this.rh;
        if (yVar != null) {
            yVar.y(luVar);
        }
    }

    public void y(Map<String, Typeface> map) {
        if (map == this.hr) {
            return;
        }
        this.hr = map;
        invalidateSelf();
    }

    public void y(l lVar) {
        this.lu = lVar;
    }

    public Bitmap y(String str, Bitmap bitmap) {
        com.bytedance.adsdk.lottie.cl.cl ns = ns();
        if (ns == null) {
            com.bytedance.adsdk.lottie.io.io.cl("Cannot update bitmap. Most likely the drawable is not added to a View which prevents Lottie from getting a Context.");
            return null;
        }
        Bitmap y2 = ns.y(str, bitmap);
        invalidateSelf();
        return y2;
    }

    @RestrictTo({RestrictTo.Scope.LIBRARY})
    public Typeface y(com.bytedance.adsdk.lottie.model.lu luVar) {
        Map<String, Typeface> map = this.hr;
        if (map != null) {
            String y2 = luVar.y();
            if (map.containsKey(y2)) {
                return map.get(y2);
            }
            String cl2 = luVar.cl();
            if (map.containsKey(cl2)) {
                return map.get(cl2);
            }
            String str = luVar.y() + "-" + luVar.lu();
            if (map.containsKey(str)) {
                return map.get(str);
            }
        }
        com.bytedance.adsdk.lottie.cl.y x = x();
        if (x != null) {
            return x.y(luVar);
        }
        return null;
    }

    private void y(Canvas canvas) {
        com.bytedance.adsdk.lottie.model.layer.p pVar = this.l;
        h hVar = this.p;
        if (pVar == null || hVar == null) {
            return;
        }
        this.aq.reset();
        if (!getBounds().isEmpty()) {
            this.aq.preScale(r2.width() / hVar.p().width(), r2.height() / hVar.p().height());
            this.aq.preTranslate(r2.left, r2.top);
        }
        pVar.y(canvas, this.aq, this.k);
    }

    private void y(Canvas canvas, com.bytedance.adsdk.lottie.model.layer.p pVar) {
        if (this.p == null || pVar == null) {
            return;
        }
        js();
        canvas.getMatrix(this.ws);
        canvas.getClipBounds(this.r);
        y(this.r, this.j);
        this.ws.mapRect(this.j);
        y(this.j, this.r);
        if (this.b) {
            this.js.set(TTAdConstant.ASPECT_CORNER_RADIUS_DEFAULT, TTAdConstant.ASPECT_CORNER_RADIUS_DEFAULT, getIntrinsicWidth(), getIntrinsicHeight());
        } else {
            pVar.y(this.js, (Matrix) null, false);
        }
        this.ws.mapRect(this.js);
        Rect bounds = getBounds();
        float width = bounds.width() / getIntrinsicWidth();
        float height = bounds.height() / getIntrinsicHeight();
        y(this.js, width, height);
        if (!ws()) {
            RectF rectF = this.js;
            Rect rect = this.r;
            rectF.intersect(rect.left, rect.top, rect.right, rect.bottom);
        }
        int ceil = (int) Math.ceil(this.js.width());
        int ceil2 = (int) Math.ceil(this.js.height());
        if (ceil == 0 || ceil2 == 0) {
            return;
        }
        cl(ceil, ceil2);
        if (this.uw) {
            this.aq.set(this.ws);
            this.aq.preScale(width, height);
            Matrix matrix = this.aq;
            RectF rectF2 = this.js;
            matrix.postTranslate(-rectF2.left, -rectF2.top);
            this.n.eraseColor(0);
            pVar.y(this.e, this.aq, this.k);
            this.ws.invert(this.je);
            this.je.mapRect(this.x, this.js);
            y(this.x, this.ns);
        }
        this.qx.set(0, 0, ceil, ceil2);
        canvas.drawBitmap(this.n, this.qx, this.ns, this.d);
    }

    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 y(Rect rect, RectF rectF) {
        rectF.set(rect.left, rect.top, rect.right, rect.bottom);
    }

    private void y(RectF rectF, float f2, float f3) {
        rectF.set(rectF.left * f2, rectF.top * f3, rectF.right * f2, rectF.bottom * f3);
    }
}