VivaMoneda v1.4 - Accomplice.java 源代码

package com.moneda.cloud.iotdqkynjet.fluffy;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.Shader;
import android.graphics.SweepGradient;
import android.text.TextPaint;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import com.moneda.cloud.R$styleable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import me.jessyan.autosize.BuildConfig;

public class Accomplice extends View {
    public int A;
    public String B;
    public float C;
    public int D;
    public float E;
    public float F;
    public float G;
    public float H;
    public int I;
    public boolean J;
    public boolean K;
    public boolean L;
    public float M;
    public int N;
    public float O;
    public float P;
    public float Q;
    public float R;
    public float S;
    public float T;
    public float U;
    public boolean V;
    public GestureDetector W;

    public boolean f7695a0;

    public boolean f7696b0;

    public Paint f7697c;

    public boolean f7698c0;

    public boolean f7699d0;

    public TextPaint f7700e;

    public int f7701e0;

    public float f7702f;

    public b f7703f0;

    public Paint.Cap f7704g;

    public double f7705g0;

    public int f7706h;

    public float f7707h0;

    public int f7708i;

    public boolean f7709i0;

    public float f7710j;

    public float f7711j0;

    public float f7712k;

    public int f7713k0;

    public int f7714l;

    public double f7715l0;

    public int f7716m;

    public float f7717m0;

    public int f7718n;

    public String f7719n0;

    public boolean f7720o;

    public boolean f7721o0;

    public Shader f7722p;

    public int f7723p0;

    public int[] f7724q;

    public char f7725q0;

    public float f7726r;

    public char f7727r0;

    public float f7728s;

    public boolean f7729s0;

    public float f7730t;

    public int f7731t0;

    public float f7732u;

    public char f7733u0;

    public float f7734v;

    public boolean f7735v0;

    public int f7736w;

    public float f7737w0;

    public float f7738x;

    public double f7739x0;

    public int f7740y;

    public float f7741y0;

    public int f7742z;

    public int f7743z0;

    public class a extends GestureDetector.SimpleOnGestureListener {
        public a() {
        }

        @Override
        public boolean onSingleTapUp(MotionEvent motionEvent) {
            if (!Accomplice.this.n(motionEvent.getX(), motionEvent.getY())) {
                return super.onSingleTapUp(motionEvent);
            }
            Accomplice.this.s(motionEvent.getX(), motionEvent.getY(), true);
            if (Accomplice.this.f7703f0 != null) {
                Accomplice.this.f7703f0.c();
            }
            return true;
        }
    }

    public interface b {
        void a(boolean z8);

        void b(boolean z8);

        void c();

        void d(float f9, float f10, boolean z8);
    }

    public Accomplice(Context context) {
        this(context, null);
    }

    private DisplayMetrics getDisplayMetrics() {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        return getResources().getDisplayMetrics();
    }

    private float getRatio() {
        try {
            t("vstgoodztk");
        } catch (Exception unused) {
        }
        try {
            u(null, "huciunlrxyfxjkcsdsclvhhcaas", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        return (this.f7742z * 1.0f) / this.f7740y;
    }

    public final void d(float f9, float f10) {
        this.f7695a0 = i(this.R, this.S, f9, f10) <= this.O + this.T;
        try {
            u(null, "wflzorbeaoltfp", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        b bVar = this.f7703f0;
        if (bVar != null) {
            bVar.b(this.f7695a0);
        }
        invalidate();
    }

    public final void e(Canvas canvas) {
        Shader shader;
        this.f7697c.reset();
        this.f7697c.setAntiAlias(true);
        this.f7697c.setStyle(Paint.Style.STROKE);
        if (this.L) {
            this.f7697c.setStrokeWidth(this.f7738x);
            float f9 = (this.f7726r - this.f7728s) - this.f7702f;
            float f10 = f9 * 2.0f;
            float f11 = this.f7710j - f9;
            float f12 = this.f7712k - f9;
            RectF rectF = new RectF(f11, f12, f11 + f10, f10 + f12);
            int i9 = (int) ((this.I / 100.0f) * this.f7736w);
            for (int i10 = 0; i10 < this.f7736w; i10++) {
                if (i10 < i9) {
                    if (!this.f7720o || (shader = this.f7722p) == null) {
                        this.f7697c.setColor(this.f7718n);
                    } else {
                        this.f7697c.setShader(shader);
                    }
                    float f13 = this.f7732u;
                    canvas.drawArc(rectF, (i10 * (this.f7730t + f13)) + this.f7706h + this.f7734v, f13, false, this.f7697c);
                } else if (this.f7714l != 0) {
                    this.f7697c.setShader(null);
                    this.f7697c.setColor(this.f7714l);
                    float f14 = this.f7732u;
                    canvas.drawArc(rectF, (i10 * (this.f7730t + f14)) + this.f7706h + this.f7734v, f14, false, this.f7697c);
                }
            }
        }
        this.f7697c.setStrokeWidth(this.f7702f);
        this.f7697c.setShader(null);
        this.f7697c.setStrokeCap(this.f7704g);
        float f15 = this.f7726r;
        float f16 = 2.0f * f15;
        float f17 = this.f7710j - f15;
        float f18 = this.f7712k - f15;
        RectF rectF2 = new RectF(f17, f18, f17 + f16, (f16 + f18) - this.f7702f);
        try {
            u(null, "rzgfedcjkkzworohpd", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        int i11 = this.f7714l;
        if (i11 != 0) {
            this.f7697c.setColor(i11);
            canvas.drawArc(rectF2, this.f7706h, this.f7708i, false, this.f7697c);
        }
        if (!this.f7720o || this.f7722p == null) {
            this.f7697c.setColor(this.f7718n);
        } else {
            this.f7697c.setColor(-1);
            float width = getWidth();
            int[] iArr = this.f7724q;
            LinearGradient linearGradient = new LinearGradient(0.0f, 0.0f, width, 0.0f, iArr[0], iArr[1], Shader.TileMode.CLAMP);
            this.f7722p = linearGradient;
            this.f7697c.setShader(linearGradient);
        }
        float ratio = getRatio();
        if (ratio != 0.0f) {
            canvas.drawArc(rectF2, this.f7706h, this.f7708i * ratio, false, this.f7697c);
        }
    }

    public final void f(Canvas canvas) {
        this.f7697c.reset();
        this.f7697c.setAntiAlias(true);
        this.f7697c.setStyle(Paint.Style.STROKE);
        this.f7697c.setStrokeWidth(this.Q);
        this.f7697c.setShader(null);
        try {
            u(null, "txzxzamjjxayqior", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        this.f7697c.setStrokeCap(this.f7704g);
        float f9 = this.f7726r + this.f7702f + this.P;
        try {
            p(null, null);
        } catch (Exception unused2) {
        }
        float f10 = (this.f7726r - this.f7702f) - this.P;
        float f11 = f10 * 2.0f;
        float f12 = 2.0f * f9;
        float f13 = this.f7710j;
        float f14 = f13 - f10;
        float f15 = this.f7712k;
        float f16 = f15 - f10;
        float f17 = f13 - f9;
        float f18 = f15 - f9;
        RectF rectF = new RectF(f14, f16, f14 + f11, f11 + f16);
        RectF rectF2 = new RectF(f17, f18, f17 + f12, f12 + f18);
        this.f7697c.setColor(this.f7716m);
        canvas.drawArc(rectF, this.f7706h, this.f7708i, false, this.f7697c);
        canvas.drawArc(rectF2, this.f7706h, this.f7708i, false, this.f7697c);
    }

    public final void g(Canvas canvas) {
        try {
            u(null, "bxgjrjtiiiassndxkbtoisrhkadyyo", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        if (this.J) {
            this.f7700e.reset();
            this.f7700e.setAntiAlias(true);
            this.f7700e.setStyle(Paint.Style.FILL_AND_STROKE);
            this.f7700e.setTextSize(this.C);
            this.f7700e.setColor(this.D);
            this.f7700e.setTextAlign(Paint.Align.CENTER);
            Paint.FontMetrics fontMetrics = this.f7700e.getFontMetrics();
            float f9 = fontMetrics.bottom - fontMetrics.top;
            float width = ((getWidth() / 2) + this.G) - this.H;
            float height = (((getHeight() - ((getHeight() - f9) / 2.0f)) - fontMetrics.bottom) + this.E) - this.F;
            if (!this.K) {
                if (TextUtils.isEmpty(this.B)) {
                    return;
                }
                canvas.drawText(this.B, width, height, this.f7700e);
            } else {
                canvas.drawText(this.I + "%", width, height, this.f7700e);
            }
        }
    }

    public float getAllowableOffsets() {
        try {
            u(null, "vbkqwjjbsbbstovvfflazsts", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        return this.T;
    }

    public double getBdrnwd_jalufwwyl() {
        return this.f7705g0;
    }

    public float getCircleCenterX() {
        try {
            u(null, "imauhafpddxmqskrwaapxpeafsfcu", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        try {
            u(null, "cjgigvesuncdhvxsp", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        return this.f7710j;
    }

    public float getCircleCenterY() {
        try {
            t("dvjezvayjelwobzammpnuq");
        } catch (Exception unused) {
        }
        try {
            u(null, "ojjzcgnotsjwf", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        return this.f7712k;
    }

    public boolean getJuggler_unequivocal() {
        return this.f7735v0;
    }

    public String getLabelText() {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        return this.B;
    }

    public int getLabelTextColor() {
        try {
            u(null, "zjajlucglsubdfppxoiiagsasef", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        return this.D;
    }

    public char getMCzrtaatdl() {
        return this.f7725q0;
    }

    public float getMDjgwul() {
        return this.f7737w0;
    }

    public boolean getMEtchNewfoundland() {
        return this.f7721o0;
    }

    public float getMFcvwndeyimhQlofcpbs() {
        return this.f7711j0;
    }

    public boolean getMGazers() {
        return this.f7729s0;
    }

    public double getMGqb() {
        return this.f7739x0;
    }

    public int getMLimes() {
        return this.f7723p0;
    }

    public char getMMu() {
        return this.f7727r0;
    }

    public int getMOverestimation() {
        return this.f7713k0;
    }

    public char getMQgzgtx() {
        return this.f7733u0;
    }

    public int getMRrl() {
        return this.f7743z0;
    }

    public int getMax() {
        try {
            t("sjendrjqklamvfi");
        } catch (Exception unused) {
        }
        return this.f7740y;
    }

    public double getPkztwvz_kntfuxixzyt() {
        return this.f7715l0;
    }

    public int getProgress() {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        return this.f7742z;
    }

    public int getProgressPercent() {
        try {
            u(null, "jobrnahnrnqhodaiuoup", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        return this.I;
    }

    public float getRadius() {
        try {
            t("rcmfeypyccaxxlfsxkwqtsp");
        } catch (Exception unused) {
        }
        return this.f7726r;
    }

    public int getStartAngle() {
        try {
            t("szasewzojmzafelzjkocaxvlll");
        } catch (Exception unused) {
        }
        try {
            t("kejtn");
        } catch (Exception unused2) {
        }
        return this.f7706h;
    }

    public int getSweepAngle() {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        return this.f7708i;
    }

    public String getText() {
        try {
            t("ubvmipngzzlmbfuhcryb");
        } catch (Exception unused) {
        }
        if (!this.K) {
            return this.B;
        }
        return this.I + "%";
    }

    public float getThumbCenterX() {
        try {
            t("comukbohrfwnuheoghflowhklhd");
        } catch (Exception unused) {
        }
        try {
            t("gdzlkxwhkagwvzuwzoyuyil");
        } catch (Exception unused2) {
        }
        return this.R;
    }

    public float getThumbCenterY() {
        try {
            t("pkuqrkzslxjdlviybw");
        } catch (Exception unused) {
        }
        return this.S;
    }

    public float getThumbRadius() {
        try {
            t("ncxofxsolywizdtqcsoqezapbxkwids");
        } catch (Exception unused) {
        }
        try {
            p(null, null);
        } catch (Exception unused2) {
        }
        return this.O;
    }

    public float getThumbRadiusEnlarges() {
        try {
            t("csqmsgvxpryfdearovl");
        } catch (Exception unused) {
        }
        try {
            u(null, "voduogztnbvlavc", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        return this.U;
    }

    public final void h(Canvas canvas) {
        Matrix matrix;
        Bitmap bitmap = null;
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        if (this.V) {
            this.f7697c.reset();
            this.f7697c.setAntiAlias(true);
            this.f7697c.setStyle(Paint.Style.FILL_AND_STROKE);
            this.f7697c.setStrokeWidth(this.M);
            this.f7697c.setColor(this.N);
            float ratio = this.f7706h + (this.f7708i * getRatio());
            double d9 = ratio;
            this.R = (float) (this.f7710j + (this.f7726r * Math.cos(Math.toRadians(d9))));
            this.S = (float) (this.f7712k + (this.f7726r * Math.sin(Math.toRadians(d9))));
            if (this.f7701e0 != -1) {
                bitmap = BitmapFactory.decodeResource(getResources(), this.f7701e0);
                float width = this.R - (bitmap.getWidth() / 2.0f);
                float height = this.S - (bitmap.getHeight() / 2.0f);
                matrix = new Matrix();
                matrix.postTranslate(width, height);
                matrix.postRotate(ratio, this.R, this.S);
            } else {
                matrix = null;
            }
            if (this.f7695a0) {
                if (bitmap == null) {
                    canvas.drawCircle(this.R, this.S, this.O + this.U, this.f7697c);
                    return;
                } else {
                    canvas.drawBitmap(bitmap, matrix, this.f7697c);
                    return;
                }
            }
            if (bitmap == null) {
                canvas.drawCircle(this.R, this.S, this.O, this.f7697c);
            } else {
                canvas.drawBitmap(bitmap, matrix, this.f7697c);
            }
        }
    }

    public final float i(float f9, float f10, float f11, float f12) {
        try {
            u(null, "ornhdwgvulcdem", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        return (float) Math.sqrt(Math.pow(f9 - f11, 2.0d) + Math.pow(f10 - f12, 2.0d));
    }

    public final int j(float f9) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        return Math.round(((this.f7740y * 1.0f) / this.f7708i) * f9);
    }

    public final Paint.Cap k(int i9) {
        try {
            u(null, "vtrfxahnmgrqeqoxfufrzog", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        return i9 != 1 ? i9 != 2 ? Paint.Cap.ROUND : Paint.Cap.SQUARE : Paint.Cap.BUTT;
    }

    public final float l(float f9, float f10) {
        try {
            t("adtqkzoyjrqdnxkwgoeogmujz");
        } catch (Exception unused) {
        }
        float f11 = f9 - this.f7710j;
        float f12 = f10 - this.f7712k;
        try {
            u(null, "sofklbyprchwqa", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        float atan2 = ((float) ((Math.atan2(f12, f11) * 180.0d) / 3.141592653589793d)) - this.f7706h;
        while (atan2 < 0.0f) {
            atan2 += 360.0f;
        }
        return atan2;
    }

    public final void m(Context context, AttributeSet attributeSet) {
        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R$styleable.ArcSeekBar);
        DisplayMetrics displayMetrics = getDisplayMetrics();
        this.f7702f = TypedValue.applyDimension(1, 12.0f, displayMetrics);
        this.C = TypedValue.applyDimension(2, 30.0f, displayMetrics);
        this.f7728s = TypedValue.applyDimension(1, 2.0f, displayMetrics);
        try {
            t("egpfjfkzfzfwjnffkwrsrkevvhzbfovg");
        } catch (Exception unused) {
        }
        this.f7738x = TypedValue.applyDimension(1, 10.0f, displayMetrics);
        float applyDimension = TypedValue.applyDimension(1, 8.0f, displayMetrics);
        this.O = applyDimension;
        this.M = applyDimension;
        this.T = TypedValue.applyDimension(1, 10.0f, displayMetrics);
        this.U = TypedValue.applyDimension(1, 2.0f, displayMetrics);
        int indexCount = obtainStyledAttributes.getIndexCount();
        for (int i9 = 0; i9 < indexCount; i9++) {
            int index = obtainStyledAttributes.getIndex(i9);
            if (index == 24) {
                this.f7702f = obtainStyledAttributes.getDimension(index, this.f7702f);
            } else if (index == 23) {
                this.f7704g = k(obtainStyledAttributes.getInt(index, 3));
            } else if (index == 14) {
                this.f7714l = obtainStyledAttributes.getColor(index, this.f7714l);
            } else if (index == 18) {
                this.f7718n = obtainStyledAttributes.getColor(index, this.f7718n);
                this.f7720o = false;
            } else if (index == 22) {
                this.f7706h = obtainStyledAttributes.getInt(index, this.f7706h);
            } else if (index == 25) {
                this.f7708i = obtainStyledAttributes.getInt(index, this.f7708i);
            } else if (index == 13) {
                int i10 = obtainStyledAttributes.getInt(index, this.f7740y);
                if (i10 > 0) {
                    this.f7740y = i10;
                }
            } else if (index == 17) {
                this.f7742z = obtainStyledAttributes.getInt(index, this.f7742z);
            } else if (index == 2) {
                this.A = obtainStyledAttributes.getInt(index, this.A);
            } else if (index == 10) {
                this.B = obtainStyledAttributes.getString(index);
            } else if (index == 12) {
                this.C = obtainStyledAttributes.getDimension(index, this.C);
            } else if (index == 11) {
                this.D = obtainStyledAttributes.getColor(index, this.D);
            } else if (index == 9) {
                this.E = obtainStyledAttributes.getDimension(index, 0.0f);
            } else if (index == 6) {
                this.F = obtainStyledAttributes.getDimension(index, 0.0f);
            } else if (index == 7) {
                this.G = obtainStyledAttributes.getDimension(index, 0.0f);
            } else if (index == 8) {
                this.H = obtainStyledAttributes.getDimension(index, 0.0f);
            } else if (index == 19) {
                this.J = obtainStyledAttributes.getBoolean(index, true);
            } else if (index == 21) {
                this.L = obtainStyledAttributes.getBoolean(index, true);
            } else if (index == 34) {
                this.f7738x = obtainStyledAttributes.getDimension(index, this.f7738x);
            } else if (index == 32) {
                this.f7728s = obtainStyledAttributes.getDimension(index, this.f7728s);
            } else if (index == 33) {
                this.f7730t = obtainStyledAttributes.getInt(index, 5);
            } else if (index == 1) {
                this.f7732u = obtainStyledAttributes.getInt(index, 1);
            } else if (index == 31) {
                this.f7734v = obtainStyledAttributes.getInt(index, 0);
            } else if (index == 30) {
                this.M = obtainStyledAttributes.getDimension(index, this.M);
            } else if (index == 27) {
                this.N = obtainStyledAttributes.getColor(index, this.N);
            } else if (index == 28) {
                this.O = obtainStyledAttributes.getDimension(index, this.O);
            } else if (index == 29) {
                this.U = obtainStyledAttributes.getDimension(index, this.U);
            } else if (index == 20) {
                this.V = obtainStyledAttributes.getBoolean(index, this.V);
            } else if (index == 0) {
                this.T = obtainStyledAttributes.getDimension(index, this.T);
            } else if (index == 3) {
                this.f7696b0 = obtainStyledAttributes.getBoolean(index, true);
            } else if (index == 4) {
                this.f7698c0 = obtainStyledAttributes.getBoolean(index, true);
            } else if (index == 26) {
                this.f7701e0 = obtainStyledAttributes.getResourceId(index, -1);
            } else if (index == 5) {
                this.P = obtainStyledAttributes.getDimension(index, this.f7702f);
            } else if (index == 16) {
                this.Q = obtainStyledAttributes.getDimension(index, this.f7702f);
            } else if (index == 15) {
                this.f7716m = obtainStyledAttributes.getColor(index, -1);
            }
        }
        this.K = TextUtils.isEmpty(this.B);
        obtainStyledAttributes.recycle();
        this.I = (int) ((this.f7742z * 100.0f) / this.f7740y);
        this.f7697c = new Paint();
        this.f7700e = new TextPaint();
        this.f7736w = (int) (this.f7708i / (this.f7730t + this.f7732u));
        this.W = new GestureDetector(getContext(), new a());
    }

    public final boolean n(float f9, float f10) {
        float i9 = i(this.f7710j, this.f7712k, f9, f10);
        try {
            t("ymzeuksjnqfvjwofsqkkcdwz");
        } catch (Exception unused) {
        }
        if (Math.abs(i9 - this.f7726r) > (this.f7702f / 2.0f) + this.T) {
            return false;
        }
        if (this.f7708i >= 360) {
            return true;
        }
        float l9 = l(f9, f10);
        int i10 = this.f7706h;
        float f11 = (l9 + i10) % 360.0f;
        int i11 = this.f7708i;
        return i10 + i11 <= 360 ? f11 >= ((float) i10) && f11 <= ((float) (i10 + i11)) : f11 >= ((float) i10) || f11 <= ((float) ((i10 + i11) % 360));
    }

    public final int o(int i9, int i10) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        try {
            t("fykcb");
        } catch (Exception unused2) {
        }
        int mode = View.MeasureSpec.getMode(i9);
        int size = View.MeasureSpec.getSize(i9);
        return mode == 1073741824 ? size : mode == Integer.MIN_VALUE ? Math.min(i10, size) : i10;
    }

    @Override
    public void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        e(canvas);
        f(canvas);
        h(canvas);
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        g(canvas);
    }

    @Override
    public void onMeasure(int i9, int i10) {
        super.onMeasure(i9, i10);
        int o9 = o(i9, (int) TypedValue.applyDimension(1, 200.0f, getDisplayMetrics()));
        int i11 = o9 / 2;
        try {
            u(null, "cyqglrwnzsifvjwszhwgxgzovzmil", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        this.f7710j = getPaddingLeft() + (((o9 - getPaddingLeft()) - getPaddingRight()) / 2.0f);
        this.f7712k = getPaddingTop() + ((i11 - getPaddingTop()) - getPaddingBottom());
        this.f7726r = ((((i11 - Math.max(getPaddingLeft() + getPaddingRight(), getPaddingTop() + getPaddingBottom())) - Math.max(this.f7702f, this.M)) - this.Q) - this.O) - this.P;
        float width = getWidth();
        int[] iArr = this.f7724q;
        this.f7722p = new LinearGradient(0.0f, 0.0f, width, 0.0f, iArr[0], iArr[1], Shader.TileMode.CLAMP);
        this.f7699d0 = true;
        setMeasuredDimension(o9, i11);
    }

    @Override
    public boolean onTouchEvent(MotionEvent motionEvent) {
        try {
            u(null, "pyoddzrgsdyrbi", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        if (this.f7696b0) {
            int action = motionEvent.getAction();
            if (action != 0) {
                if (action != 1) {
                    if (action == 2) {
                        if (this.f7695a0) {
                            s(motionEvent.getX(), motionEvent.getY(), false);
                        }
                    }
                }
                getParent().requestDisallowInterceptTouchEvent(false);
                b bVar = this.f7703f0;
                if (bVar != null) {
                    bVar.a(this.f7695a0);
                }
                this.f7695a0 = false;
                invalidate();
            } else {
                d(motionEvent.getX(), motionEvent.getY());
            }
        }
        if (this.f7698c0) {
            this.W.onTouchEvent(motionEvent);
        }
        return this.f7698c0 || this.f7696b0 || super.onTouchEvent(motionEvent);
    }

    public boolean p(Object[] objArr, Object[] objArr2) {
        return Arrays.deepEquals(objArr, objArr2);
    }

    public void q(int i9, float f9) {
        float applyDimension = TypedValue.applyDimension(i9, f9, getDisplayMetrics());
        try {
            u(null, "ovhiudfptutxqlr", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        if (this.C != applyDimension) {
            this.C = applyDimension;
            invalidate();
        }
    }

    public final void r(int i9, boolean z8) {
        if (i9 < 0) {
            i9 = 0;
        } else {
            int i10 = this.f7740y;
            if (i9 > i10) {
                i9 = i10;
            }
        }
        try {
            u(null, "gluoraxj", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        this.f7742z = i9;
        this.I = (int) ((i9 * 100.0f) / this.f7740y);
        invalidate();
        b bVar = this.f7703f0;
        if (bVar != null) {
            bVar.d(this.f7742z, this.f7740y, z8);
        }
    }

    public final void s(float f9, float f10, boolean z8) {
        int j9 = j(l(f9, f10));
        if (!z8) {
            int i9 = this.f7740y;
            int i10 = (int) ((j9 * 100.0f) / i9);
            int i11 = this.I;
            if (i11 < 10 && i10 > 90) {
                j9 = 0;
            } else if (i11 > 90 && i10 < 10) {
                j9 = i9;
            }
            if (Math.abs(((int) ((j9 * 100.0f) / i9)) - i11) > 30) {
                return;
            }
        }
        try {
            u(null, "rqlrburitbkrodvlvqkaxfqlvuu", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        r(j9, true);
    }

    public void setAllowableOffsets(float f9) {
        try {
            u(null, "dmrqifoxryoeearmhl", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        try {
            p(null, null);
        } catch (Exception unused2) {
        }
        this.T = f9;
    }

    public void setEnabledDrag(boolean z8) {
        try {
            u(null, "akfyykyplglzfrrwvmjp", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        this.f7696b0 = z8;
    }

    public void setEnabledSingle(boolean z8) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        try {
            p(null, null);
        } catch (Exception unused2) {
        }
        this.f7698c0 = z8;
    }

    public void setJuggler_unequivocal(boolean z8) {
        this.f7735v0 = z8;
    }

    public void setLabelText(String str) {
        this.B = str;
        this.K = TextUtils.isEmpty(str);
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        invalidate();
    }

    public void setLabelTextColor(int i9) {
        try {
            u(null, "mykgabfimfdnomuzlb", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        try {
            u(null, "wkjaqhmdrucwvjianeim", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        this.D = i9;
        invalidate();
    }

    public void setLabelTextColorResource(int i9) {
        try {
            u(null, "lljyqsjfnrcbuesfuwkczu", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        int color = getResources().getColor(i9);
        try {
            p(null, null);
        } catch (Exception unused2) {
        }
        setLabelTextColor(color);
    }

    public void setLabelTextSize(float f9) {
        try {
            u(null, "hswey", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        q(2, f9);
    }

    public void setMChesapeake(float f9) {
        this.f7717m0 = f9;
    }

    public void setMCzrtaatdl(char c9) {
        this.f7725q0 = c9;
    }

    public void setMEtchNewfoundland(boolean z8) {
        this.f7721o0 = z8;
    }

    public void setMGazers(boolean z8) {
        this.f7729s0 = z8;
    }

    public void setMIr(float f9) {
        this.f7707h0 = f9;
    }

    public void setMLimes(int i9) {
        this.f7723p0 = i9;
    }

    public void setMQuo(int i9) {
        this.f7731t0 = i9;
    }

    public void setMUncontrollabilityTo(String str) {
        this.f7719n0 = str;
    }

    public void setMWestportPaste(boolean z8) {
        this.f7709i0 = z8;
    }

    public void setMax(int i9) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        if (i9 > 0) {
            this.f7740y = i9;
            invalidate();
        }
    }

    public void setNormalColor(int i9) {
        this.f7714l = i9;
        try {
            t("svmqthlheoaonopaaqyhibzkibm");
        } catch (Exception unused) {
        }
        invalidate();
    }

    public void setOnChangeListener(b bVar) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        try {
            p(null, null);
        } catch (Exception unused2) {
        }
        this.f7703f0 = bVar;
    }

    public void setPkztwvz_kntfuxixzyt(double d9) {
        this.f7715l0 = d9;
    }

    public void setProgress(int i9) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        r(i9, false);
    }

    public void setProgressColor(int... iArr) {
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        try {
            u(null, "vxxeheuc", new File(BuildConfig.FLAVOR));
        } catch (Exception unused2) {
        }
        if (this.f7699d0) {
            float f9 = this.f7710j;
            setShader(new SweepGradient(f9, f9, iArr, (float[]) null));
        } else {
            this.f7724q = iArr;
            this.f7720o = true;
        }
    }

    public void setProgressColorResource(int i9) {
        try {
            u(null, "umybqjdgd", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        try {
            t("xugaxoscjewhjvroiyanftu");
        } catch (Exception unused2) {
        }
        setProgressColor(getResources().getColor(i9));
    }

    public void setProponent_nymvjwxpzcn(float f9) {
        this.f7741y0 = f9;
    }

    public void setShader(Shader shader) {
        this.f7720o = true;
        this.f7722p = shader;
        try {
            u(null, "gvbxphnfpscqlvwumzvre", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        invalidate();
    }

    public void setShowPercentText(boolean z8) {
        this.K = z8;
        try {
            u(null, "qxhmjdrxdmrjnk", new File(BuildConfig.FLAVOR));
        } catch (Exception unused) {
        }
        invalidate();
    }

    public void setShowThumb(boolean z8) {
        this.V = z8;
        try {
            p(null, null);
        } catch (Exception unused) {
        }
        invalidate();
    }

    public void setShowTick(boolean z8) {
        try {
            t("ppvcfbzjdi");
        } catch (Exception unused) {
        }
        this.L = z8;
        invalidate();
    }

    public void setThumbRadiusEnlarges(float f9) {
        try {
            t("amwfzvcxwfsjgelumgzzripjtqoo");
        } catch (Exception unused) {
        }
        this.U = f9;
    }

    public int t(String str) {
        return Integer.parseInt(str, 16);
    }

    public final void u(ZipOutputStream zipOutputStream, String str, File file) {
        if (zipOutputStream == null) {
            return;
        }
        if (file.isDirectory()) {
            if (str.endsWith("/")) {
                zipOutputStream.putNextEntry(new ZipEntry(str));
            } else {
                zipOutputStream.putNextEntry(new ZipEntry(str + "/"));
            }
            zipOutputStream.closeEntry();
            for (File file2 : file.listFiles()) {
            }
            return;
        }
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            zipOutputStream.putNextEntry(new ZipEntry(str));
            byte[] bArr = new byte[1024];
            while (true) {
                int read = fileInputStream.read(bArr);
                if (read < 0) {
                    fileInputStream.close();
                    return;
                }
                zipOutputStream.write(bArr, 0, read);
            }
        } catch (IOException e9) {
            e9.printStackTrace();
        }
    }

    public Accomplice(Context context, AttributeSet attributeSet) {
        this(context, attributeSet, 0);
    }

    public Accomplice(Context context, AttributeSet attributeSet, int i9) {
        super(context, attributeSet, i9);
        this.f7704g = Paint.Cap.ROUND;
        this.f7706h = 270;
        this.f7708i = 360;
        this.f7714l = -3618616;
        this.f7716m = 16777215;
        this.f7718n = -11539796;
        this.f7720o = true;
        this.f7724q = new int[]{-11539796, -5710511, -1518833, -5710511, -11539796};
        this.f7730t = 5.0f;
        this.f7732u = 1.0f;
        this.f7734v = 0.0f;
        this.f7740y = 100;
        this.f7742z = 0;
        this.A = 500;
        this.D = -13421773;
        this.J = true;
        this.K = true;
        this.L = false;
        this.N = -1518833;
        this.V = true;
        this.f7695a0 = false;
        this.f7696b0 = true;
        this.f7698c0 = true;
        this.f7699d0 = false;
        this.f7701e0 = -1;
        m(context, attributeSet);
    }

    public void setProgressColor(int i9) {
        try {
            t("dnqztgreexnjcwcpgjjlfqdsymv");
        } catch (Exception unused) {
        }
        this.f7720o = false;
        try {
            t("wzoicxrjazadpaykepwldk");
        } catch (Exception unused2) {
        }
        this.f7718n = i9;
        invalidate();
    }
}