导航菜单

页面标题

页面副标题

漫天星 v3.0.2 - SubsamplingScaleImageViewDragClose.java 源代码

正在查看: 漫天星 v3.0.2 应用的 SubsamplingScaleImageViewDragClose.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件,支持语法高亮显示。 仅供安全研究与技术分析使用,严禁用于任何非法用途。请遵守相关法律法规。


package com.junyue.basic.glide.view.helper;

import android.content.Context;
import android.content.res.TypedArray;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewParent;
import androidx.annotation.AnyThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.exifinterface.media.ExifInterface;
import com.google.android.material.bottomappbar.BottomAppBarTopEdgeTreatment;
import com.junyue.basic.R$styleable;
import com.junyue.basic.glide.view.decoder.SkiaImageDecoder;
import com.junyue.basic.glide.view.decoder.SkiaImageRegionDecoder;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Executor;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class SubsamplingScaleImageViewDragClose extends View {
    public static final String c1 = SubsamplingScaleImageViewDragClose.class.getSimpleName();
    public static final List<Integer> d1 = Arrays.asList(0, 90, 180, Integer.valueOf(BottomAppBarTopEdgeTreatment.ANGLE_UP), -1);
    public static final List<Integer> e1 = Arrays.asList(1, 2, 3);
    public static final List<Integer> f1 = Arrays.asList(2, 1);
    public static final List<Integer> g1 = Arrays.asList(1, 2, 3);
    public static final List<Integer> h1 = Arrays.asList(2, 1, 3, 4);
    public static Bitmap.Config i1;
    public Map<Integer, List<m>> A;
    public PointF A0;
    public boolean B;
    public PointF B0;
    public int C;
    public e C0;
    public float D;
    public boolean D0;
    public int E;
    public boolean E0;
    public int F;
    public j F0;
    public int G;
    public k G0;
    public int H;
    public View.OnLongClickListener H0;
    public int I;
    public Paint I0;
    public Executor J;
    public Paint J0;
    public boolean K;
    public Paint K0;
    public boolean L;
    public Paint L0;
    public boolean M;
    public l M0;
    public boolean N;
    public Matrix N0;
    public float O;
    public RectF O0;
    public int P;
    public h P0;
    public int Q;
    public final ViewConfiguration Q0;
    public float R;
    public int R0;
    public float S;
    public int S0;
    public PointF T;
    public long T0;
    public PointF U;
    public int U0;
    public PointF V;
    public int V0;
    public Float W;
    public boolean W0;
    public RectF X0;
    public RectF Y0;
    public f.p.c.c0.e Z0;
    public final Handler a1;
    public int b1;
    public PointF e0;
    public PointF f0;
    public int g0;
    public int h0;
    public int i0;
    public float j0;
    public Rect k0;
    public Rect l0;
    public boolean m0;
    public final ReadWriteLock n;
    public boolean n0;
    public final float o;
    public boolean o0;
    public final Handler p;
    public int p0;
    public final float[] q;
    public GestureDetector q0;
    public final float[] r;
    public GestureDetector r0;
    public final float s;
    public f.p.c.k.n.a.d s0;
    public boolean t;
    public f.p.c.k.n.a.b<? extends f.p.c.k.n.a.c> t0;
    public boolean u;
    public f.p.c.k.n.a.b<? extends f.p.c.k.n.a.d> u0;
    public Bitmap v;
    public PointF v0;
    public boolean w;
    public float w0;
    public boolean x;
    public float x0;
    public Uri y;
    public boolean y0;
    public int z;
    public PointF z0;

    public class a implements Handler.Callback {
        public a() {
        }

        @Override
        public boolean handleMessage(Message message) {
            if (message.what == 1 && SubsamplingScaleImageViewDragClose.this.H0 != null) {
                SubsamplingScaleImageViewDragClose.this.p0 = 0;
                SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = SubsamplingScaleImageViewDragClose.this;
                SubsamplingScaleImageViewDragClose.super.setOnLongClickListener(subsamplingScaleImageViewDragClose.H0);
                SubsamplingScaleImageViewDragClose.this.performLongClick();
                SubsamplingScaleImageViewDragClose.super.setOnLongClickListener(null);
            }
            return true;
        }
    }

    public class b extends GestureDetector.SimpleOnGestureListener {
        public final Context n;

        public b(Context context) {
            this.n = context;
        }

        @Override
        public boolean onDoubleTap(MotionEvent motionEvent) {
            if (!SubsamplingScaleImageViewDragClose.this.M || !SubsamplingScaleImageViewDragClose.this.D0 || SubsamplingScaleImageViewDragClose.this.T == null) {
                return super.onDoubleTapEvent(motionEvent);
            }
            SubsamplingScaleImageViewDragClose.this.setGestureDetector(this.n);
            if (!SubsamplingScaleImageViewDragClose.this.N) {
                SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = SubsamplingScaleImageViewDragClose.this;
                subsamplingScaleImageViewDragClose.X(subsamplingScaleImageViewDragClose.V0(new PointF(motionEvent.getX(), motionEvent.getY())), new PointF(motionEvent.getX(), motionEvent.getY()));
                return true;
            }
            SubsamplingScaleImageViewDragClose.this.v0 = new PointF(motionEvent.getX(), motionEvent.getY());
            SubsamplingScaleImageViewDragClose.this.U = new PointF(SubsamplingScaleImageViewDragClose.this.T.x, SubsamplingScaleImageViewDragClose.this.T.y);
            SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose2 = SubsamplingScaleImageViewDragClose.this;
            subsamplingScaleImageViewDragClose2.S = subsamplingScaleImageViewDragClose2.R;
            SubsamplingScaleImageViewDragClose.this.o0 = true;
            SubsamplingScaleImageViewDragClose.this.m0 = true;
            SubsamplingScaleImageViewDragClose.this.x0 = -1.0f;
            SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose3 = SubsamplingScaleImageViewDragClose.this;
            subsamplingScaleImageViewDragClose3.A0 = subsamplingScaleImageViewDragClose3.V0(subsamplingScaleImageViewDragClose3.v0);
            SubsamplingScaleImageViewDragClose.this.B0 = new PointF(motionEvent.getX(), motionEvent.getY());
            SubsamplingScaleImageViewDragClose.this.z0 = new PointF(SubsamplingScaleImageViewDragClose.this.A0.x, SubsamplingScaleImageViewDragClose.this.A0.y);
            SubsamplingScaleImageViewDragClose.this.y0 = false;
            return false;
        }

        @Override
        public boolean onFling(MotionEvent motionEvent, MotionEvent motionEvent2, float f2, float f3) {
            if (!SubsamplingScaleImageViewDragClose.this.L || !SubsamplingScaleImageViewDragClose.this.D0 || SubsamplingScaleImageViewDragClose.this.T == null || motionEvent == null || motionEvent2 == null || ((Math.abs(motionEvent.getX() - motionEvent2.getX()) <= 50.0f && Math.abs(motionEvent.getY() - motionEvent2.getY()) <= 50.0f) || ((Math.abs(f2) <= 500.0f && Math.abs(f3) <= 500.0f) || SubsamplingScaleImageViewDragClose.this.m0))) {
                return super.onFling(motionEvent, motionEvent2, f2, f3);
            }
            PointF pointF = new PointF(SubsamplingScaleImageViewDragClose.this.T.x + (f2 * 0.25f), SubsamplingScaleImageViewDragClose.this.T.y + (f3 * 0.25f));
            f fVar = new f(SubsamplingScaleImageViewDragClose.this, new PointF(((SubsamplingScaleImageViewDragClose.this.getWidth() / 2) - pointF.x) / SubsamplingScaleImageViewDragClose.this.R, ((SubsamplingScaleImageViewDragClose.this.getHeight() / 2) - pointF.y) / SubsamplingScaleImageViewDragClose.this.R), (a) null);
            fVar.e(1);
            f.a(fVar, false);
            f.b(fVar, 3);
            fVar.c();
            return true;
        }

        @Override
        public boolean onSingleTapConfirmed(MotionEvent motionEvent) {
            SubsamplingScaleImageViewDragClose.this.performClick();
            return true;
        }
    }

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

        @Override
        public boolean onSingleTapConfirmed(MotionEvent motionEvent) {
            SubsamplingScaleImageViewDragClose.this.performClick();
            return true;
        }
    }

    public class d implements Runnable {
        public final int n;

        public d(int i) {
            this.n = i;
        }

        @Override
        public void run() {
            SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = SubsamplingScaleImageViewDragClose.this;
            if (subsamplingScaleImageViewDragClose.b1 == 1) {
                int i = this.n;
                if (i == 1) {
                    subsamplingScaleImageViewDragClose.Z0.G();
                    e.a.b.f.d.a("isSelected", "中间", new Object[0]);
                } else if (i == 2) {
                    subsamplingScaleImageViewDragClose.Z0.a();
                    e.a.b.f.d.a("isSelected", "左边", new Object[0]);
                } else if (i == 3) {
                    subsamplingScaleImageViewDragClose.Z0.f0();
                    e.a.b.f.d.a("isSelected", "右边", new Object[0]);
                }
            }
            SubsamplingScaleImageViewDragClose.this.a1.removeCallbacksAndMessages(null);
            SubsamplingScaleImageViewDragClose.this.b1 = 0;
        }
    }

    public final class f {
        public final float a;
        public final PointF b;
        public final PointF c;
        public long d;
        public int e;

        public int f20f;

        public boolean f21g;
        public boolean h;
        public i i;

        public f(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, float f2, PointF pointF, PointF pointF2, a aVar) {
            this(f2, pointF, pointF2);
        }

        public static f a(f fVar, boolean z) {
            fVar.h(z);
            return fVar;
        }

        public static f b(f fVar, int i) {
            fVar.g(i);
            return fVar;
        }

        public void c() {
            PointF pointF;
            if (SubsamplingScaleImageViewDragClose.this.C0 != null && SubsamplingScaleImageViewDragClose.this.C0.m != null) {
                try {
                    SubsamplingScaleImageViewDragClose.this.C0.m.b();
                } catch (Exception e) {
                    Log.w(SubsamplingScaleImageViewDragClose.c1, "Error thrown by animation listener", e);
                }
            }
            int paddingLeft = SubsamplingScaleImageViewDragClose.this.getPaddingLeft() + (((SubsamplingScaleImageViewDragClose.this.getWidth() - SubsamplingScaleImageViewDragClose.this.getPaddingRight()) - SubsamplingScaleImageViewDragClose.this.getPaddingLeft()) / 2);
            int paddingTop = SubsamplingScaleImageViewDragClose.this.getPaddingTop() + (((SubsamplingScaleImageViewDragClose.this.getHeight() - SubsamplingScaleImageViewDragClose.this.getPaddingBottom()) - SubsamplingScaleImageViewDragClose.this.getPaddingTop()) / 2);
            float n0 = SubsamplingScaleImageViewDragClose.this.n0(this.a);
            if (this.h) {
                SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = SubsamplingScaleImageViewDragClose.this;
                PointF pointF2 = this.b;
                float f2 = pointF2.x;
                float f3 = pointF2.y;
                pointF = new PointF();
                SubsamplingScaleImageViewDragClose.L(subsamplingScaleImageViewDragClose, f2, f3, n0, pointF);
            } else {
                pointF = this.b;
            }
            a aVar = null;
            SubsamplingScaleImageViewDragClose.this.C0 = new e(aVar);
            SubsamplingScaleImageViewDragClose.this.C0.a = SubsamplingScaleImageViewDragClose.this.R;
            SubsamplingScaleImageViewDragClose.this.C0.b = n0;
            SubsamplingScaleImageViewDragClose.this.C0.l = System.currentTimeMillis();
            SubsamplingScaleImageViewDragClose.this.C0.e = pointF;
            SubsamplingScaleImageViewDragClose.this.C0.c = SubsamplingScaleImageViewDragClose.this.getCenter();
            SubsamplingScaleImageViewDragClose.this.C0.d = pointF;
            SubsamplingScaleImageViewDragClose.this.C0.f18f = SubsamplingScaleImageViewDragClose.this.N0(pointF);
            SubsamplingScaleImageViewDragClose.this.C0.f19g = new PointF(paddingLeft, paddingTop);
            SubsamplingScaleImageViewDragClose.this.C0.h = this.d;
            SubsamplingScaleImageViewDragClose.this.C0.i = this.f21g;
            SubsamplingScaleImageViewDragClose.this.C0.j = this.e;
            SubsamplingScaleImageViewDragClose.this.C0.k = this.f20f;
            SubsamplingScaleImageViewDragClose.this.C0.l = System.currentTimeMillis();
            SubsamplingScaleImageViewDragClose.this.C0.m = this.i;
            PointF pointF3 = this.c;
            if (pointF3 != null) {
                float f4 = pointF3.x - (SubsamplingScaleImageViewDragClose.this.C0.c.x * n0);
                float f5 = this.c.y - (SubsamplingScaleImageViewDragClose.this.C0.c.y * n0);
                l lVar = new l(n0, new PointF(f4, f5), aVar);
                SubsamplingScaleImageViewDragClose.this.e0(true, lVar);
                SubsamplingScaleImageViewDragClose.this.C0.f19g = new PointF(this.c.x + (lVar.a.x - f4), this.c.y + (lVar.a.y - f5));
            }
            SubsamplingScaleImageViewDragClose.this.invalidate();
        }

        @NonNull
        public f d(long j) {
            this.d = j;
            return this;
        }

        @NonNull
        public f e(int i) {
            if (SubsamplingScaleImageViewDragClose.f1.contains(Integer.valueOf(i))) {
                this.e = i;
                return this;
            }
            throw new IllegalArgumentException("Unknown easing type: " + i);
        }

        @NonNull
        public f f(boolean z) {
            this.f21g = z;
            return this;
        }

        @NonNull
        public final f g(int i) {
            this.f20f = i;
            return this;
        }

        @NonNull
        public final f h(boolean z) {
            this.h = z;
            return this;
        }

        public f(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, float f2, PointF pointF, a aVar) {
            this(f2, pointF);
        }

        public f(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, PointF pointF, a aVar) {
            this(pointF);
        }

        public f(PointF pointF) {
            this.d = 500L;
            this.e = 2;
            this.f20f = 1;
            this.f21g = true;
            this.h = true;
            this.a = SubsamplingScaleImageViewDragClose.this.R;
            this.b = pointF;
            this.c = null;
        }

        public f(float f2, PointF pointF) {
            this.d = 500L;
            this.e = 2;
            this.f20f = 1;
            this.f21g = true;
            this.h = true;
            this.a = f2;
            this.b = pointF;
            this.c = null;
        }

        public f(float f2, PointF pointF, PointF pointF2) {
            this.d = 500L;
            this.e = 2;
            this.f20f = 1;
            this.f21g = true;
            this.h = true;
            this.a = f2;
            this.b = pointF;
            this.c = pointF2;
        }
    }

    public static class g extends AsyncTask<Void, Void, Integer> {
        public final WeakReference<SubsamplingScaleImageViewDragClose> a;
        public final WeakReference<Context> b;
        public final WeakReference<f.p.c.k.n.a.b<? extends f.p.c.k.n.a.c>> c;
        public final Uri d;
        public final boolean e;

        public Bitmap f22f;

        public Exception f23g;

        public g(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, Context context, f.p.c.k.n.a.b<? extends f.p.c.k.n.a.c> bVar, Uri uri, boolean z) {
            this.a = new WeakReference<>(subsamplingScaleImageViewDragClose);
            this.b = new WeakReference<>(context);
            this.c = new WeakReference<>(bVar);
            this.d = uri;
            this.e = z;
        }

        @Override
        public Integer doInBackground(Void... voidArr) {
            try {
                String uri = this.d.toString();
                Context context = this.b.get();
                f.p.c.k.n.a.b<? extends f.p.c.k.n.a.c> bVar = this.c.get();
                SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = this.a.get();
                if (context == null || bVar == null || subsamplingScaleImageViewDragClose == null) {
                    return null;
                }
                subsamplingScaleImageViewDragClose.V("BitmapLoadTask.doInBackground", new Object[0]);
                this.f22f = bVar.a().a(context, this.d);
                return Integer.valueOf(subsamplingScaleImageViewDragClose.f0(context, uri));
            } catch (Exception e) {
                Log.e(SubsamplingScaleImageViewDragClose.c1, "Failed to load bitmap", e);
                this.f23g = e;
                return null;
            } catch (OutOfMemoryError e2) {
                Log.e(SubsamplingScaleImageViewDragClose.c1, "Failed to load bitmap - OutOfMemoryError", e2);
                this.f23g = new RuntimeException(e2);
                return null;
            }
        }

        @Override
        public void onPostExecute(Integer num) {
            SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = this.a.get();
            if (subsamplingScaleImageViewDragClose != null) {
                Bitmap bitmap = this.f22f;
                if (bitmap != null && num != null) {
                    if (this.e) {
                        subsamplingScaleImageViewDragClose.r0(bitmap);
                        return;
                    } else {
                        subsamplingScaleImageViewDragClose.q0(bitmap, num.intValue(), false);
                        return;
                    }
                }
                if (this.f23g == null || subsamplingScaleImageViewDragClose.F0 == null) {
                    return;
                }
                if (this.e) {
                    subsamplingScaleImageViewDragClose.F0.b(this.f23g);
                } else {
                    subsamplingScaleImageViewDragClose.F0.f(this.f23g);
                }
            }
        }
    }

    public interface h {
        boolean a();
    }

    public interface i {
        void a();

        void b();

        void onComplete();
    }

    public interface j {
        void a();

        void b(Exception exc);

        void c(Exception exc);

        void d();

        void e();

        void f(Exception exc);
    }

    public interface k {
        void a(float f2, int i);

        void b(PointF pointF, int i);
    }

    public static class l {
        public final PointF a;
        public float b;

        public l(float f2, PointF pointF, a aVar) {
            this(f2, pointF);
        }

        public l(float f2, PointF pointF) {
            this.b = f2;
            this.a = pointF;
        }
    }

    public static class m {
        public Rect a;
        public int b;
        public Bitmap c;
        public boolean d;
        public boolean e;

        public Rect f24f;

        public Rect f25g;

        public m() {
        }

        public m(a aVar) {
            this();
        }
    }

    public static class n extends AsyncTask<Void, Void, Bitmap> {
        public final WeakReference<SubsamplingScaleImageViewDragClose> a;
        public final WeakReference<f.p.c.k.n.a.d> b;
        public final WeakReference<m> c;
        public Exception d;

        public n(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, f.p.c.k.n.a.d dVar, m mVar) {
            this.a = new WeakReference<>(subsamplingScaleImageViewDragClose);
            this.b = new WeakReference<>(dVar);
            this.c = new WeakReference<>(mVar);
            mVar.d = true;
        }

        @Override
        public Bitmap doInBackground(Void... voidArr) {
            try {
                SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = this.a.get();
                f.p.c.k.n.a.d dVar = this.b.get();
                m mVar = this.c.get();
                if (dVar == null || mVar == null || subsamplingScaleImageViewDragClose == null || !dVar.isReady() || !mVar.e) {
                    if (mVar == null) {
                        return null;
                    }
                    mVar.d = false;
                    return null;
                }
                subsamplingScaleImageViewDragClose.V("TileLoadTask.doInBackground, tile.sRect=%s, tile.sampleSize=%d", mVar.a, Integer.valueOf(mVar.b));
                subsamplingScaleImageViewDragClose.n.readLock().lock();
                try {
                    if (!dVar.isReady()) {
                        mVar.d = false;
                        subsamplingScaleImageViewDragClose.n.readLock().unlock();
                        return null;
                    }
                    subsamplingScaleImageViewDragClose.c0(mVar.a, mVar.f25g);
                    if (subsamplingScaleImageViewDragClose.k0 != null) {
                        mVar.f25g.offset(subsamplingScaleImageViewDragClose.k0.left, subsamplingScaleImageViewDragClose.k0.top);
                    }
                    return dVar.b(mVar.f25g, mVar.b);
                } finally {
                    subsamplingScaleImageViewDragClose.n.readLock().unlock();
                }
            } catch (Exception e) {
                Log.e(SubsamplingScaleImageViewDragClose.c1, "Failed to decode tile", e);
                this.d = e;
                return null;
            } catch (OutOfMemoryError e2) {
                Log.e(SubsamplingScaleImageViewDragClose.c1, "Failed to decode tile - OutOfMemoryError", e2);
                this.d = new RuntimeException(e2);
                return null;
            }
        }

        @Override
        public void onPostExecute(Bitmap bitmap) {
            SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = this.a.get();
            m mVar = this.c.get();
            if (subsamplingScaleImageViewDragClose == null || mVar == null) {
                return;
            }
            if (bitmap != null) {
                mVar.c = bitmap;
                mVar.d = false;
                subsamplingScaleImageViewDragClose.t0();
            } else {
                if (this.d == null || subsamplingScaleImageViewDragClose.F0 == null) {
                    return;
                }
                subsamplingScaleImageViewDragClose.F0.c(this.d);
            }
        }
    }

    public static class o extends AsyncTask<Void, Void, int[]> {
        public final WeakReference<SubsamplingScaleImageViewDragClose> a;
        public final WeakReference<Context> b;
        public final WeakReference<f.p.c.k.n.a.b<? extends f.p.c.k.n.a.d>> c;
        public final Uri d;
        public f.p.c.k.n.a.d e;

        public Exception f26f;

        public o(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, Context context, f.p.c.k.n.a.b<? extends f.p.c.k.n.a.d> bVar, Uri uri) {
            this.a = new WeakReference<>(subsamplingScaleImageViewDragClose);
            this.b = new WeakReference<>(context);
            this.c = new WeakReference<>(bVar);
            this.d = uri;
        }

        @Override
        public int[] doInBackground(Void... voidArr) {
            try {
                String uri = this.d.toString();
                Context context = this.b.get();
                f.p.c.k.n.a.b<? extends f.p.c.k.n.a.d> bVar = this.c.get();
                SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = this.a.get();
                if (context == null || bVar == null || subsamplingScaleImageViewDragClose == null) {
                    return null;
                }
                subsamplingScaleImageViewDragClose.V("TilesInitTask.doInBackground", new Object[0]);
                f.p.c.k.n.a.d a = bVar.a();
                this.e = a;
                Point a2 = a.a(context, this.d);
                int i = a2.x;
                int i2 = a2.y;
                int f0 = subsamplingScaleImageViewDragClose.f0(context, uri);
                if (subsamplingScaleImageViewDragClose.k0 != null) {
                    subsamplingScaleImageViewDragClose.k0.left = Math.max(0, subsamplingScaleImageViewDragClose.k0.left);
                    subsamplingScaleImageViewDragClose.k0.top = Math.max(0, subsamplingScaleImageViewDragClose.k0.top);
                    subsamplingScaleImageViewDragClose.k0.right = Math.min(i, subsamplingScaleImageViewDragClose.k0.right);
                    subsamplingScaleImageViewDragClose.k0.bottom = Math.min(i2, subsamplingScaleImageViewDragClose.k0.bottom);
                    i = subsamplingScaleImageViewDragClose.k0.width();
                    i2 = subsamplingScaleImageViewDragClose.k0.height();
                }
                return new int[]{i, i2, f0};
            } catch (Exception e) {
                Log.e(SubsamplingScaleImageViewDragClose.c1, "Failed to initialise bitmap decoder", e);
                this.f26f = e;
                return null;
            }
        }

        @Override
        public void onPostExecute(int[] iArr) {
            SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose = this.a.get();
            if (subsamplingScaleImageViewDragClose != null) {
                f.p.c.k.n.a.d dVar = this.e;
                if (dVar != null && iArr != null && iArr.length == 3) {
                    subsamplingScaleImageViewDragClose.u0(dVar, iArr[0], iArr[1], iArr[2]);
                } else {
                    if (this.f26f == null || subsamplingScaleImageViewDragClose.F0 == null) {
                        return;
                    }
                    subsamplingScaleImageViewDragClose.F0.f(this.f26f);
                }
            }
        }
    }

    public SubsamplingScaleImageViewDragClose(Context context, AttributeSet attributeSet) {
        super(context, attributeSet);
        int resourceId;
        String string;
        this.n = new ReentrantReadWriteLock(true);
        this.q = new float[8];
        this.r = new float[8];
        this.C = 0;
        this.D = 2.0f;
        this.E = -1;
        this.F = 1;
        this.G = 1;
        this.H = Integer.MAX_VALUE;
        this.I = Integer.MAX_VALUE;
        this.J = AsyncTask.THREAD_POOL_EXECUTOR;
        this.K = true;
        this.L = true;
        this.M = true;
        this.N = true;
        this.O = 1.0f;
        this.P = 1;
        this.Q = 500;
        this.j0 = o0();
        this.t0 = new f.p.c.k.n.a.a(SkiaImageDecoder.class);
        this.u0 = new f.p.c.k.n.a.a(SkiaImageRegionDecoder.class);
        this.Q0 = ViewConfiguration.get(getContext());
        this.R0 = 0;
        this.S0 = 0;
        this.U0 = 0;
        this.V0 = 0;
        this.W0 = false;
        this.X0 = null;
        this.Y0 = null;
        this.a1 = new Handler();
        this.s = getResources().getDisplayMetrics().density;
        setMinimumDpi(160);
        setDoubleTapZoomDpi(160);
        setMinimumTileDpi(320);
        setGestureDetector(context);
        ViewConfiguration.get(context).getScaledPagingTouchSlop();
        this.p = new Handler(new a());
        if (attributeSet != null) {
            TypedArray obtainStyledAttributes = getContext().obtainStyledAttributes(attributeSet, R$styleable.SubsamplingScaleImageView);
            if (obtainStyledAttributes.hasValue(R$styleable.SubsamplingScaleImageView_assetName) && (string = obtainStyledAttributes.getString(R$styleable.SubsamplingScaleImageView_assetName)) != null && string.length() > 0) {
                f.p.c.k.n.b.a a2 = f.p.c.k.n.b.a.a(string);
                a2.p();
                setImage(a2);
            }
            if (obtainStyledAttributes.hasValue(R$styleable.SubsamplingScaleImageView_src) && (resourceId = obtainStyledAttributes.getResourceId(R$styleable.SubsamplingScaleImageView_src, 0)) > 0) {
                f.p.c.k.n.b.a l2 = f.p.c.k.n.b.a.l(resourceId);
                l2.p();
                setImage(l2);
            }
            if (obtainStyledAttributes.hasValue(R$styleable.SubsamplingScaleImageView_panEnabled)) {
                setPanEnabled(obtainStyledAttributes.getBoolean(R$styleable.SubsamplingScaleImageView_panEnabled, true));
            }
            if (obtainStyledAttributes.hasValue(R$styleable.SubsamplingScaleImageView_zoomEnabled)) {
                setZoomEnabled(obtainStyledAttributes.getBoolean(R$styleable.SubsamplingScaleImageView_zoomEnabled, true));
            }
            if (obtainStyledAttributes.hasValue(R$styleable.SubsamplingScaleImageView_quickScaleEnabled)) {
                setQuickScaleEnabled(obtainStyledAttributes.getBoolean(R$styleable.SubsamplingScaleImageView_quickScaleEnabled, true));
            }
            if (obtainStyledAttributes.hasValue(R$styleable.SubsamplingScaleImageView_tileBackgroundColor)) {
                setTileBackgroundColor(obtainStyledAttributes.getColor(R$styleable.SubsamplingScaleImageView_tileBackgroundColor, Color.argb(0, 0, 0, 0)));
            }
            obtainStyledAttributes.recycle();
        }
        this.o = TypedValue.applyDimension(1, 20.0f, context.getResources().getDisplayMetrics());
    }

    public static PointF L(SubsamplingScaleImageViewDragClose subsamplingScaleImageViewDragClose, float f2, float f3, float f4, PointF pointF) {
        subsamplingScaleImageViewDragClose.m0(f2, f3, f4, pointF);
        return pointF;
    }

    public static Bitmap.Config getPreferredBitmapConfig() {
        return i1;
    }

    @AnyThread
    private int getRequiredRotation() {
        int i2 = this.C;
        return i2 == -1 ? this.i0 : i2;
    }

    public void setGestureDetector(Context context) {
        this.q0 = new GestureDetector(context, new b(context));
        this.r0 = new GestureDetector(context, new c());
    }

    public static void setPreferredBitmapConfig(Bitmap.Config config) {
        i1 = config;
    }

    public final void A0(boolean z) {
        ViewParent parent = getParent();
        if (parent != null) {
            parent.requestDisallowInterceptTouchEvent(z);
        }
    }

    public final void B0(boolean z) {
        j jVar;
        V("reset newImage=" + z, new Object[0]);
        this.R = 0.0f;
        this.S = 0.0f;
        this.T = null;
        this.U = null;
        this.V = null;
        this.W = Float.valueOf(0.0f);
        this.e0 = null;
        this.f0 = null;
        this.m0 = false;
        this.n0 = false;
        this.o0 = false;
        this.p0 = 0;
        this.z = 0;
        this.v0 = null;
        this.w0 = 0.0f;
        this.x0 = 0.0f;
        this.y0 = false;
        this.A0 = null;
        this.z0 = null;
        this.B0 = null;
        this.C0 = null;
        this.M0 = null;
        this.N0 = null;
        this.O0 = null;
        if (z) {
            this.y = null;
            this.n.writeLock().lock();
            try {
                if (this.s0 != null) {
                    this.s0.recycle();
                    this.s0 = null;
                }
                this.n.writeLock().unlock();
                Bitmap bitmap = this.v;
                if (bitmap != null && !this.x) {
                    bitmap.recycle();
                }
                if (this.v != null && this.x && (jVar = this.F0) != null) {
                    jVar.d();
                }
                this.g0 = 0;
                this.h0 = 0;
                this.i0 = 0;
                this.k0 = null;
                this.l0 = null;
                this.D0 = false;
                this.E0 = false;
                this.v = null;
                this.w = false;
                this.x = false;
            } catch (Throwable th) {
                this.n.writeLock().unlock();
                throw th;
            }
        }
        Map<Integer, List<m>> map = this.A;
        if (map != null) {
            Iterator<Map.Entry<Integer, List<m>>> it = map.entrySet().iterator();
            while (it.hasNext()) {
                for (m mVar : it.next().getValue()) {
                    mVar.e = false;
                    if (mVar.c != null) {
                        mVar.c.recycle();
                        mVar.c = null;
                    }
                }
            }
            this.A = null;
        }
        setGestureDetector(getContext());
    }

    public final void C0() {
        this.C0 = null;
        this.W = Float.valueOf(n0(0.0f));
        if (l0()) {
            this.e0 = new PointF(G0() / 2, F0() / 2);
        } else {
            this.e0 = new PointF(0.0f, 0.0f);
        }
        invalidate();
    }

    public final void D0(f.p.c.k.n.a.f fVar) {
        if (fVar == null || !d1.contains(Integer.valueOf(fVar.b()))) {
            return;
        }
        this.C = fVar.b();
        this.W = Float.valueOf(fVar.c());
        this.e0 = fVar.a();
        invalidate();
    }

    public void E0(int i2) {
        this.b1++;
        this.a1.postDelayed(new d(i2), 180L);
    }

    public final int F0() {
        int requiredRotation = getRequiredRotation();
        return (requiredRotation == 90 || requiredRotation == 270) ? this.g0 : this.h0;
    }

    public final int G0() {
        int requiredRotation = getRequiredRotation();
        return (requiredRotation == 90 || requiredRotation == 270) ? this.h0 : this.g0;
    }

    public final void H0(float f2, PointF pointF, int i2) {
        k kVar = this.G0;
        if (kVar != null) {
            float f3 = this.R;
            if (f3 != f2) {
                kVar.a(f3, i2);
            }
        }
        if (this.G0 == null || this.T.equals(pointF)) {
            return;
        }
        this.G0.b(getCenter(), i2);
    }

    public final void I0(@NonNull f.p.c.k.n.b.a aVar, f.p.c.k.n.b.a aVar2) {
        J0(aVar, aVar2, null);
    }

    public final void J0(@NonNull f.p.c.k.n.b.a aVar, f.p.c.k.n.b.a aVar2, f.p.c.k.n.a.f fVar) {
        if (aVar == null) {
            throw new NullPointerException("imageSource must not be null");
        }
        B0(true);
        if (fVar != null) {
            D0(fVar);
        }
        if (aVar2 != null) {
            if (aVar.d() != null) {
                throw new IllegalArgumentException("Preview image cannot be used when a bitmap is provided for the main image");
            }
            if (aVar.h() <= 0 || aVar.f() <= 0) {
                throw new IllegalArgumentException("Preview image cannot be used unless dimensions are provided for the main image");
            }
            this.g0 = aVar.h();
            this.h0 = aVar.f();
            this.l0 = aVar2.g();
            if (aVar2.d() != null) {
                this.x = aVar2.k();
                r0(aVar2.d());
            } else {
                Uri j2 = aVar2.j();
                if (j2 == null && aVar2.e() != null) {
                    j2 = Uri.parse("android.resource://" + getContext().getPackageName() + "/" + aVar2.e());
                }
                b0(new g(this, getContext(), this.t0, j2, true));
            }
        }
        if (aVar.d() != null && aVar.g() != null) {
            q0(Bitmap.createBitmap(aVar.d(), aVar.g().left, aVar.g().top, aVar.g().width(), aVar.g().height()), 0, false);
            return;
        }
        if (aVar.d() != null) {
            q0(aVar.d(), 0, aVar.k());
            return;
        }
        this.k0 = aVar.g();
        Uri j3 = aVar.j();
        this.y = j3;
        if (j3 == null && aVar.e() != null) {
            this.y = Uri.parse("android.resource://" + getContext().getPackageName() + "/" + aVar.e());
        }
        if (aVar.i() || this.k0 != null) {
            b0(new o(this, getContext(), this.u0, this.y));
        } else {
            b0(new g(this, getContext(), this.t0, this.y, false));
        }
    }

    public final void K0(float[] fArr, float f2, float f3, float f4, float f5, float f6, float f7, float f8, float f9) {
        fArr[0] = f2;
        fArr[1] = f3;
        fArr[2] = f4;
        fArr[3] = f5;
        fArr[4] = f6;
        fArr[5] = f7;
        fArr[6] = f8;
        fArr[7] = f9;
    }

    public final void L0(float f2, @Nullable PointF pointF) {
        this.C0 = null;
        this.W = Float.valueOf(f2);
        this.e0 = pointF;
        this.f0 = pointF;
        invalidate();
    }

    @Nullable
    public final PointF M0(float f2, float f3, @NonNull PointF pointF) {
        if (this.T == null) {
            return null;
        }
        pointF.set(P0(f2), Q0(f3));
        return pointF;
    }

    @Nullable
    public final PointF N0(PointF pointF) {
        return M0(pointF.x, pointF.y, new PointF());
    }

    public final void O0(@NonNull Rect rect, @NonNull Rect rect2) {
        rect2.set((int) P0(rect.left), (int) Q0(rect.top), (int) P0(rect.right), (int) Q0(rect.bottom));
    }

    public final float P0(float f2) {
        PointF pointF = this.T;
        if (pointF == null) {
            return Float.NaN;
        }
        return (f2 * this.R) + pointF.x;
    }

    public final float Q0(float f2) {
        PointF pointF = this.T;
        if (pointF == null) {
            return Float.NaN;
        }
        return (f2 * this.R) + pointF.y;
    }

    public final int R(float f2) {
        int round;
        if (this.E > 0) {
            DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
            f2 *= this.E / ((displayMetrics.xdpi + displayMetrics.ydpi) / 2.0f);
        }
        int G0 = (int) (G0() * f2);
        int F0 = (int) (F0() * f2);
        if (G0 == 0 || F0 == 0) {
            return 32;
        }
        int i2 = 1;
        if (F0() > F0 || G0() > G0) {
            round = Math.round(F0() / F0);
            int round2 = Math.round(G0() / G0);
            if (round >= round2) {
                round = round2;
            }
        } else {
            round = 1;
        }
        while (true) {
            int i3 = i2 * 2;
            if (i3 >= round) {
                return i2;
            }
            i2 = i3;
        }
    }

    public final boolean R0(m mVar) {
        return W0(0.0f) <= ((float) mVar.a.right) && ((float) mVar.a.left) <= W0((float) getWidth()) && X0(0.0f) <= ((float) mVar.a.bottom) && ((float) mVar.a.top) <= X0((float) getHeight());
    }

    public final boolean S() {
        boolean j0 = j0();
        if (!this.E0 && j0) {
            w0();
            this.E0 = true;
            p0();
            j jVar = this.F0;
            if (jVar != null) {
                jVar.a();
            }
        }
        return j0;
    }

    @NonNull
    public final PointF S0(float f2, float f3, float f4) {
        int paddingLeft = getPaddingLeft() + (((getWidth() - getPaddingRight()) - getPaddingLeft()) / 2);
        int paddingTop = getPaddingTop() + (((getHeight() - getPaddingBottom()) - getPaddingTop()) / 2);
        if (this.M0 == null) {
            this.M0 = new l(0.0f, new PointF(0.0f, 0.0f), null);
        }
        this.M0.b = f4;
        this.M0.a.set(paddingLeft - (f2 * f4), paddingTop - (f3 * f4));
        e0(true, this.M0);
        return this.M0.a;
    }

    public final boolean T() {
        boolean z = getWidth() > 0 && getHeight() > 0 && this.g0 > 0 && this.h0 > 0 && (this.v != null || j0());
        if (!this.D0 && z) {
            w0();
            this.D0 = true;
            s0();
            j jVar = this.F0;
            if (jVar != null) {
                jVar.e();
            }
        }
        return z;
    }

    @Nullable
    public final PointF T0(float f2, float f3) {
        return U0(f2, f3, new PointF());
    }

    public final void U() {
        if (this.I0 == null) {
            Paint paint = new Paint();
            this.I0 = paint;
            paint.setAntiAlias(true);
            this.I0.setFilterBitmap(true);
            this.I0.setDither(true);
        }
        if ((this.J0 == null || this.K0 == null) && this.B) {
            Paint paint2 = new Paint();
            this.J0 = paint2;
            paint2.setTextSize(x0(12));
            this.J0.setColor(-65281);
            this.J0.setStyle(Paint.Style.FILL);
            Paint paint3 = new Paint();
            this.K0 = paint3;
            paint3.setColor(-65281);
            this.K0.setStyle(Paint.Style.STROKE);
            this.K0.setStrokeWidth(x0(1));
        }
    }

    @Nullable
    public final PointF U0(float f2, float f3, @NonNull PointF pointF) {
        if (this.T == null) {
            return null;
        }
        pointF.set(W0(f2), X0(f3));
        return pointF;
    }

    @AnyThread
    public final void V(String str, Object... objArr) {
        if (this.B) {
            Log.d(c1, String.format(str, objArr));
        }
    }

    @Nullable
    public final PointF V0(PointF pointF) {
        return U0(pointF.x, pointF.y, new PointF());
    }

    public final float W(float f2, float f3, float f4, float f5) {
        float f6 = f2 - f3;
        float f7 = f4 - f5;
        return (float) Math.sqrt((f6 * f6) + (f7 * f7));
    }

    public final float W0(float f2) {
        PointF pointF = this.T;
        if (pointF == null) {
            return Float.NaN;
        }
        return (f2 - pointF.x) / this.R;
    }

    public final void X(PointF pointF, PointF pointF2) {
        if (!this.L) {
            PointF pointF3 = this.f0;
            if (pointF3 != null) {
                pointF.x = pointF3.x;
                pointF.y = pointF3.y;
            } else {
                pointF.x = G0() / 2;
                pointF.y = F0() / 2;
            }
        }
        float min = Math.min(this.D, this.O);
        float f2 = this.R;
        boolean z = ((double) f2) <= ((double) min) * 0.9d || f2 == this.j0;
        if (!z) {
            min = o0();
        }
        float f3 = min;
        int i2 = this.P;
        if (i2 == 3) {
            L0(f3, pointF);
        } else if (i2 == 2 || !z || !this.L) {
            f fVar = new f(this, f3, pointF, (a) null);
            fVar.f(false);
            fVar.d(this.Q);
            f.b(fVar, 4);
            fVar.c();
        } else if (i2 == 1) {
            f fVar2 = new f(this, f3, pointF, pointF2, null);
            fVar2.f(false);
            fVar2.d(this.Q);
            f.b(fVar2, 4);
            fVar2.c();
        }
        invalidate();
    }

    public final float X0(float f2) {
        PointF pointF = this.T;
        if (pointF == null) {
            return Float.NaN;
        }
        return (f2 - pointF.y) / this.R;
    }

    public final float Y(int i2, long j2, float f2, float f3, long j3) {
        if (i2 == 1) {
            return a0(j2, f2, f3, j3);
        }
        if (i2 == 2) {
            return Z(j2, f2, f3, j3);
        }
        throw new IllegalStateException("Unexpected easing type: " + i2);
    }

    public final float Z(long j2, float f2, float f3, long j3) {
        float f4;
        float f5 = j2 / (j3 / 2.0f);
        if (f5 < 1.0f) {
            f4 = (f3 / 2.0f) * f5;
        } else {
            float f6 = f5 - 1.0f;
            f4 = (-f3) / 2.0f;
            f5 = (f6 * (f6 - 2.0f)) - 1.0f;
        }
        return (f4 * f5) + f2;
    }

    public final float a0(long j2, float f2, float f3, long j3) {
        float f4 = j2 / j3;
        return ((-f3) * f4 * (f4 - 2.0f)) + f2;
    }

    public final void b0(AsyncTask<Void, Void, ?> asyncTask) {
        asyncTask.executeOnExecutor(this.J, new Void[0]);
    }

    @AnyThread
    public final void c0(Rect rect, Rect rect2) {
        if (getRequiredRotation() == 0) {
            rect2.set(rect);
            return;
        }
        if (getRequiredRotation() == 90) {
            int i2 = rect.top;
            int i3 = this.h0;
            rect2.set(i2, i3 - rect.right, rect.bottom, i3 - rect.left);
        } else if (getRequiredRotation() != 180) {
            int i4 = this.g0;
            rect2.set(i4 - rect.bottom, rect.left, i4 - rect.top, rect.right);
        } else {
            int i5 = this.g0;
            int i6 = i5 - rect.right;
            int i7 = this.h0;
            rect2.set(i6, i7 - rect.bottom, i5 - rect.left, i7 - rect.top);
        }
    }

    public final void d0(boolean z) {
        boolean z2;
        float f2 = 0.0f;
        if (this.T == null) {
            z2 = true;
            this.T = new PointF(0.0f, 0.0f);
        } else {
            z2 = false;
        }
        if (this.M0 == null) {
            this.M0 = new l(f2, new PointF(0.0f, 0.0f), null);
        }
        this.M0.b = this.R;
        this.M0.a.set(this.T);
        e0(z, this.M0);
        this.R = this.M0.b;
        this.T.set(this.M0.a);
        if (!z2 || this.G == 4) {
            return;
        }
        this.T.set(S0(G0() / 2, F0() / 2, this.R));
    }

    public final void e0(boolean z, l lVar) {
        float max;
        int max2;
        float max3;
        if (this.F == 2 && l0()) {
            z = false;
        }
        PointF pointF = lVar.a;
        float n0 = n0(lVar.b);
        float G0 = G0() * n0;
        float F0 = F0() * n0;
        if (this.F == 3 && l0()) {
            pointF.x = Math.max(pointF.x, (getWidth() / 2) - G0);
            pointF.y = Math.max(pointF.y, (getHeight() / 2) - F0);
        } else if (z) {
            pointF.x = Math.max(pointF.x, getWidth() - G0);
            pointF.y = Math.max(pointF.y, getHeight() - F0);
        } else {
            pointF.x = Math.max(pointF.x, -G0);
            pointF.y = Math.max(pointF.y, -F0);
        }
        float paddingLeft = (getPaddingLeft() > 0 || getPaddingRight() > 0) ? getPaddingLeft() / (getPaddingLeft() + getPaddingRight()) : 0.5f;
        float paddingTop = (getPaddingTop() > 0 || getPaddingBottom() > 0) ? getPaddingTop() / (getPaddingTop() + getPaddingBottom()) : 0.5f;
        if (this.F == 3 && l0()) {
            max = Math.max(0, getWidth() / 2);
            max2 = Math.max(0, getHeight() / 2);
        } else {
            if (z) {
                max = Math.max(0.0f, (getWidth() - G0) * paddingLeft);
                max3 = Math.max(0.0f, (getHeight() - F0) * paddingTop);
                pointF.x = Math.min(pointF.x, max);
                pointF.y = Math.min(pointF.y, max3);
                lVar.b = n0;
            }
            max = Math.max(0, getWidth());
            max2 = Math.max(0, getHeight());
        }
        max3 = max2;
        pointF.x = Math.min(pointF.x, max);
        pointF.y = Math.min(pointF.y, max3);
        lVar.b = n0;
    }

    @AnyThread
    public final int f0(Context context, String str) {
        int i2;
        int i3 = 0;
        if (!str.startsWith("content")) {
            if (!str.startsWith("file:///") || str.startsWith("file:///android_asset/")) {
                return 0;
            }
            try {
                int attributeInt = new ExifInterface(str.substring(7)).getAttributeInt("Orientation", 1);
                if (attributeInt != 1 && attributeInt != 0) {
                    if (attributeInt == 6) {
                        i2 = 90;
                    } else if (attributeInt == 3) {
                        i2 = 180;
                    } else {
                        if (attributeInt != 8) {
                            Log.w(c1, "Unsupported EXIF orientation: " + attributeInt);
                            return 0;
                        }
                        i2 = BottomAppBarTopEdgeTreatment.ANGLE_UP;
                    }
                    return i2;
                }
                return 0;
            } catch (Exception unused) {
                Log.w(c1, "Could not get EXIF orientation of image");
                return 0;
            }
        }
        Cursor cursor = null;
        try {
            try {
                cursor = context.getContentResolver().query(Uri.parse(str), new String[]{"orientation"}, null, null, null);
                if (cursor != null && cursor.moveToFirst()) {
                    int i4 = cursor.getInt(0);
                    if (!d1.contains(Integer.valueOf(i4)) || i4 == -1) {
                        Log.w(c1, "Unsupported orientation: " + i4);
                    } else {
                        i3 = i4;
                    }
                }
                if (cursor == null) {
                    return i3;
                }
            } catch (Exception unused2) {
                Log.w(c1, "Could not get orientation of image from media store");
                if (cursor == null) {
                    return 0;
                }
            }
            cursor.close();
            return i3;
        } catch (Throwable th) {
            if (cursor != null) {
                cursor.close();
            }
            throw th;
        }
    }

    @NonNull
    public final Point g0(Canvas canvas) {
        return new Point(Math.min(canvas.getMaximumBitmapWidth(), this.H), Math.min(canvas.getMaximumBitmapHeight(), this.I));
    }

    public final int getAppliedOrientation() {
        return getRequiredRotation();
    }

    @Nullable
    public final PointF getCenter() {
        return T0(getWidth() / 2, getHeight() / 2);
    }

    public float getMaxScale() {
        return this.D;
    }

    public int getMaxTouchCount() {
        return this.p0;
    }

    public final float getMinScale() {
        return o0();
    }

    public final int getOrientation() {
        return this.C;
    }

    public final int getSHeight() {
        return this.h0;
    }

    public final int getSWidth() {
        return this.g0;
    }

    public final float getScale() {
        return this.R;
    }

    @Nullable
    public final f.p.c.k.n.a.f getState() {
        if (this.T == null || this.g0 <= 0 || this.h0 <= 0) {
            return null;
        }
        return new f.p.c.k.n.a.f(getScale(), getCenter(), getOrientation());
    }

    public final synchronized void h0(@NonNull Point point) {
        V("initialiseBaseLayer maxTileDimensions=%dx%d", Integer.valueOf(point.x), Integer.valueOf(point.y));
        l lVar = new l(0.0f, new PointF(0.0f, 0.0f), null);
        this.M0 = lVar;
        e0(true, lVar);
        int R = R(this.M0.b);
        this.z = R;
        if (R > 1) {
            this.z = R / 2;
        }
        if (this.z != 1 || this.k0 != null || G0() >= point.x || F0() >= point.y) {
            i0(point);
            Iterator<m> it = this.A.get(Integer.valueOf(this.z)).iterator();
            while (it.hasNext()) {
                b0(new n(this, this.s0, it.next()));
            }
            z0(true);
        } else {
            this.s0.recycle();
            this.s0 = null;
            b0(new g(this, getContext(), this.t0, this.y, false));
        }
    }

    public final void i0(Point point) {
        int i2 = 0;
        int i3 = 1;
        V("initialiseTileMap maxTileDimensions=%dx%d", Integer.valueOf(point.x), Integer.valueOf(point.y));
        this.A = new LinkedHashMap();
        int i4 = this.z;
        int i5 = 1;
        int i6 = 1;
        while (true) {
            int G0 = G0() / i5;
            int F0 = F0() / i6;
            int i7 = G0 / i4;
            int i8 = F0 / i4;
            while (true) {
                if (i7 + i5 + i3 > point.x || (i7 > getWidth() * 1.25d && i4 < this.z)) {
                    i5++;
                    G0 = G0() / i5;
                    i7 = G0 / i4;
                    i3 = i3;
                    i2 = i2;
                }
            }
            while (true) {
                if (i8 + i6 + i3 > point.y || (i8 > getHeight() * 1.25d && i4 < this.z)) {
                    i6++;
                    F0 = F0() / i6;
                    i8 = F0 / i4;
                    i3 = i3;
                    i2 = i2;
                }
            }
            ArrayList arrayList = new ArrayList(i5 * i6);
            int i9 = i2;
            while (i9 < i5) {
                int i10 = i2;
                while (i10 < i6) {
                    m mVar = new m(null);
                    mVar.b = i4;
                    mVar.e = i4 == this.z ? i3 : i2;
                    mVar.a = new Rect(i9 * G0, i10 * F0, i9 == i5 + (-1) ? G0() : (i9 + 1) * G0, i10 == i6 + (-1) ? F0() : (i10 + 1) * F0);
                    mVar.f24f = new Rect(0, 0, 0, 0);
                    mVar.f25g = new Rect(mVar.a);
                    arrayList.add(mVar);
                    i10++;
                    i2 = 0;
                    i3 = 1;
                }
                i9++;
                i3 = 1;
            }
            int i11 = i2;
            this.A.put(Integer.valueOf(i4), arrayList);
            if (i4 == 1) {
                return;
            }
            i4 /= 2;
            i3 = 1;
            i2 = i11;
        }
    }

    public final boolean j0() {
        boolean z = true;
        if (this.v != null && !this.w) {
            return true;
        }
        Map<Integer, List<m>> map = this.A;
        if (map == null) {
            return false;
        }
        for (Map.Entry<Integer, List<m>> entry : map.entrySet()) {
            if (entry.getKey().intValue() == this.z) {
                for (m mVar : entry.getValue()) {
                    if (mVar.d || mVar.c == null) {
                        z = false;
                    }
                }
            }
        }
        return z;
    }

    public boolean k0() {
        h hVar = this.P0;
        if (hVar == null) {
            return false;
        }
        return hVar.a();
    }

    public final boolean l0() {
        return this.D0;
    }

    @NonNull
    public final PointF m0(float f2, float f3, float f4, @NonNull PointF pointF) {
        PointF S0 = S0(f2, f3, f4);
        pointF.set(((getPaddingLeft() + (((getWidth() - getPaddingRight()) - getPaddingLeft()) / 2)) - S0.x) / f4, ((getPaddingTop() + (((getHeight() - getPaddingBottom()) - getPaddingTop()) / 2)) - S0.y) / f4);
        return pointF;
    }

    public final float n0(float f2) {
        return Math.min(this.D, Math.max(o0(), f2));
    }

    public final float o0() {
        int paddingBottom = getPaddingBottom() + getPaddingTop();
        int paddingLeft = getPaddingLeft() + getPaddingRight();
        int i2 = this.G;
        if (i2 == 2 || i2 == 4) {
            return Math.max((getWidth() - paddingLeft) / G0(), (getHeight() - paddingBottom) / F0());
        }
        if (i2 == 3) {
            float f2 = this.j0;
            if (f2 > 0.0f) {
                return f2;
            }
        }
        return Math.min((getWidth() - paddingLeft) / G0(), (getHeight() - paddingBottom) / F0());
    }

    @Override
    public void onDraw(Canvas canvas) {
        int i2;
        int i3;
        float f2;
        int i4;
        int i5;
        int i6;
        super.onDraw(canvas);
        U();
        if (this.g0 == 0 || this.h0 == 0 || getWidth() == 0 || getHeight() == 0) {
            return;
        }
        if (this.A == null && this.s0 != null) {
            h0(g0(canvas));
        }
        if (T()) {
            w0();
            e eVar = this.C0;
            if (eVar != null && eVar.f18f != null) {
                float f3 = this.R;
                if (this.V == null) {
                    this.V = new PointF(0.0f, 0.0f);
                }
                this.V.set(this.T);
                long currentTimeMillis = System.currentTimeMillis() - this.C0.l;
                boolean z = currentTimeMillis > this.C0.h;
                long min = Math.min(currentTimeMillis, this.C0.h);
                this.R = Y(this.C0.j, min, this.C0.a, this.C0.b - this.C0.a, this.C0.h);
                float Y = Y(this.C0.j, min, this.C0.f18f.x, this.C0.f19g.x - this.C0.f18f.x, this.C0.h);
                float Y2 = Y(this.C0.j, min, this.C0.f18f.y, this.C0.f19g.y - this.C0.f18f.y, this.C0.h);
                this.T.x -= P0(this.C0.d.x) - Y;
                this.T.y -= Q0(this.C0.d.y) - Y2;
                d0(z || this.C0.a == this.C0.b);
                H0(f3, this.V, this.C0.k);
                z0(z);
                if (z) {
                    if (this.C0.m != null) {
                        try {
                            this.C0.m.onComplete();
                        } catch (Exception e2) {
                            Log.w(c1, "Error thrown by animation listener", e2);
                        }
                    }
                    this.C0 = null;
                }
                invalidate();
            }
            int i7 = 35;
            int i8 = 90;
            int i9 = 180;
            if (this.A == null || !j0()) {
                i2 = 35;
                i3 = 15;
                if (this.v != null) {
                    float f4 = this.R;
                    if (this.w) {
                        f4 *= this.g0 / r0.getWidth();
                        f2 = this.R * (this.h0 / this.v.getHeight());
                    } else {
                        f2 = f4;
                    }
                    if (this.N0 == null) {
                        this.N0 = new Matrix();
                    }
                    this.N0.reset();
                    this.N0.postScale(f4, f2);
                    this.N0.postRotate(getRequiredRotation());
                    Matrix matrix = this.N0;
                    PointF pointF = this.T;
                    matrix.postTranslate(pointF.x, pointF.y);
                    if (getRequiredRotation() == 180) {
                        Matrix matrix2 = this.N0;
                        float f5 = this.R;
                        matrix2.postTranslate(this.g0 * f5, f5 * this.h0);
                    } else if (getRequiredRotation() == 90) {
                        this.N0.postTranslate(this.R * this.h0, 0.0f);
                    } else if (getRequiredRotation() == 270) {
                        this.N0.postTranslate(0.0f, this.R * this.g0);
                    }
                    if (this.L0 != null) {
                        if (this.O0 == null) {
                            this.O0 = new RectF();
                        }
                        this.O0.set(0.0f, 0.0f, this.w ? this.v.getWidth() : this.g0, this.w ? this.v.getHeight() : this.h0);
                        this.N0.mapRect(this.O0);
                        canvas.drawRect(this.O0, this.L0);
                    }
                    canvas.drawBitmap(this.v, this.N0, this.I0);
                }
            } else {
                int min2 = Math.min(this.z, R(this.R));
                boolean z2 = false;
                for (Map.Entry<Integer, List<m>> entry : this.A.entrySet()) {
                    if (entry.getKey().intValue() == min2) {
                        for (m mVar : entry.getValue()) {
                            if (mVar.e && (mVar.d || mVar.c == null)) {
                                z2 = true;
                            }
                        }
                    }
                }
                for (Map.Entry<Integer, List<m>> entry2 : this.A.entrySet()) {
                    if (entry2.getKey().intValue() == min2 || z2) {
                        for (m mVar2 : entry2.getValue()) {
                            O0(mVar2.a, mVar2.f24f);
                            if (mVar2.d || mVar2.c == null) {
                                i4 = i9;
                                i5 = i8;
                                if (mVar2.d && this.B) {
                                    i6 = 35;
                                    canvas.drawText("LOADING", mVar2.f24f.left + x0(5), mVar2.f24f.top + x0(35), this.J0);
                                    if (!mVar2.e && this.B) {
                                        canvas.drawText("ISS " + mVar2.b + " RECT " + mVar2.a.top + "," + mVar2.a.left + "," + mVar2.a.bottom + "," + mVar2.a.right, mVar2.f24f.left + x0(5), mVar2.f24f.top + x0(15), this.J0);
                                    }
                                    i7 = i6;
                                    i9 = i4;
                                    i8 = i5;
                                }
                            } else {
                                if (this.L0 != null) {
                                    canvas.drawRect(mVar2.f24f, this.L0);
                                }
                                if (this.N0 == null) {
                                    this.N0 = new Matrix();
                                }
                                this.N0.reset();
                                i4 = i9;
                                i5 = i8;
                                K0(this.q, 0.0f, 0.0f, mVar2.c.getWidth(), 0.0f, mVar2.c.getWidth(), mVar2.c.getHeight(), 0.0f, mVar2.c.getHeight());
                                if (getRequiredRotation() == 0) {
                                    K0(this.r, mVar2.f24f.left, mVar2.f24f.top, mVar2.f24f.right, mVar2.f24f.top, mVar2.f24f.right, mVar2.f24f.bottom, mVar2.f24f.left, mVar2.f24f.bottom);
                                } else if (getRequiredRotation() == i5) {
                                    K0(this.r, mVar2.f24f.right, mVar2.f24f.top, mVar2.f24f.right, mVar2.f24f.bottom, mVar2.f24f.left, mVar2.f24f.bottom, mVar2.f24f.left, mVar2.f24f.top);
                                } else if (getRequiredRotation() == i4) {
                                    K0(this.r, mVar2.f24f.right, mVar2.f24f.bottom, mVar2.f24f.left, mVar2.f24f.bottom, mVar2.f24f.left, mVar2.f24f.top, mVar2.f24f.right, mVar2.f24f.top);
                                } else if (getRequiredRotation() == 270) {
                                    K0(this.r, mVar2.f24f.left, mVar2.f24f.bottom, mVar2.f24f.left, mVar2.f24f.top, mVar2.f24f.right, mVar2.f24f.top, mVar2.f24f.right, mVar2.f24f.bottom);
                                }
                                this.N0.setPolyToPoly(this.q, 0, this.r, 0, 4);
                                canvas.drawBitmap(mVar2.c, this.N0, this.I0);
                                if (this.B) {
                                    canvas.drawRect(mVar2.f24f, this.K0);
                                }
                            }
                            i6 = 35;
                            if (!mVar2.e) {
                            }
                            i7 = i6;
                            i9 = i4;
                            i8 = i5;
                        }
                    }
                    i7 = i7;
                    i9 = i9;
                    i8 = i8;
                }
                i2 = i7;
                i3 = 15;
            }
            if (this.B) {
                canvas.drawText("Scale: " + String.format(Locale.ENGLISH, "%.2f", Float.valueOf(this.R)) + " (" + String.format(Locale.ENGLISH, "%.2f", Float.valueOf(o0())) + " - " + String.format(Locale.ENGLISH, "%.2f", Float.valueOf(this.D)) + ")", x0(5), x0(i3), this.J0);
                StringBuilder sb = new StringBuilder();
                sb.append("Translate: ");
                sb.append(String.format(Locale.ENGLISH, "%.2f", Float.valueOf(this.T.x)));
                sb.append(":");
                sb.append(String.format(Locale.ENGLISH, "%.2f", Float.valueOf(this.T.y)));
                canvas.drawText(sb.toString(), (float) x0(5), (float) x0(30), this.J0);
                PointF center = getCenter();
                canvas.drawText("Source center: " + String.format(Locale.ENGLISH, "%.2f", Float.valueOf(center.x)) + ":" + String.format(Locale.ENGLISH, "%.2f", Float.valueOf(center.y)), x0(5), x0(45), this.J0);
                e eVar2 = this.C0;
                if (eVar2 != null) {
                    PointF N0 = N0(eVar2.c);
                    PointF N02 = N0(this.C0.e);
                    PointF N03 = N0(this.C0.d);
                    canvas.drawCircle(N0.x, N0.y, x0(10), this.K0);
                    this.K0.setColor(-65536);
                    canvas.drawCircle(N02.x, N02.y, x0(20), this.K0);
                    this.K0.setColor(-16776961);
                    canvas.drawCircle(N03.x, N03.y, x0(25), this.K0);
                    this.K0.setColor(-16711681);
                    canvas.drawCircle(getWidth() / 2, getHeight() / 2, x0(30), this.K0);
                }
                if (this.v0 != null) {
                    this.K0.setColor(-65536);
                    PointF pointF2 = this.v0;
                    canvas.drawCircle(pointF2.x, pointF2.y, x0(20), this.K0);
                }
                if (this.A0 != null) {
                    this.K0.setColor(-16776961);
                    canvas.drawCircle(P0(this.A0.x), Q0(this.A0.y), x0(i2), this.K0);
                }
                if (this.B0 != null && this.o0) {
                    this.K0.setColor(-16711681);
                    PointF pointF3 = this.B0;
                    canvas.drawCircle(pointF3.x, pointF3.y, x0(30), this.K0);
                }
                this.K0.setColor(-65281);
            }
        }
    }

    @Override
    public void onMeasure(int i2, int i3) {
        this.R0 = View.MeasureSpec.getSize(i2);
        this.S0 = View.MeasureSpec.getSize(i3);
        int mode = View.MeasureSpec.getMode(i2);
        int mode2 = View.MeasureSpec.getMode(i3);
        int size = View.MeasureSpec.getSize(i2);
        int size2 = View.MeasureSpec.getSize(i3);
        boolean z = mode != 1073741824;
        boolean z2 = mode2 != 1073741824;
        if (this.g0 > 0 && this.h0 > 0) {
            if (z && z2) {
                size = G0();
                size2 = F0();
            } else if (z2) {
                size2 = (int) ((F0() / G0()) * size);
            } else if (z) {
                size = (int) ((G0() / F0()) * size2);
            }
        }
        setMeasuredDimension(Math.max(size, getSuggestedMinimumWidth()), Math.max(size2, getSuggestedMinimumHeight()));
    }

    @Override
    public void onSizeChanged(int i2, int i3, int i4, int i5) {
        V("onSizeChanged %dx%d -> %dx%d", Integer.valueOf(i4), Integer.valueOf(i5), Integer.valueOf(i2), Integer.valueOf(i3));
        PointF center = getCenter();
        if (!this.D0 || center == null) {
            return;
        }
        this.C0 = null;
        this.W = Float.valueOf(this.R);
        this.e0 = center;
    }

    @Override
    public boolean onTouchEvent(@NonNull MotionEvent motionEvent) {
        f.p.c.c0.e eVar;
        GestureDetector gestureDetector;
        e eVar2 = this.C0;
        if (eVar2 != null && !eVar2.i) {
            A0(true);
            return true;
        }
        e eVar3 = this.C0;
        if (eVar3 != null && eVar3.m != null) {
            try {
                this.C0.m.a();
            } catch (Exception e2) {
                Log.w(c1, "Error thrown by animation listener", e2);
            }
        }
        this.C0 = null;
        if (this.T == null) {
            GestureDetector gestureDetector2 = this.r0;
            if (gestureDetector2 != null) {
                gestureDetector2.onTouchEvent(motionEvent);
            }
            return true;
        }
        if (!this.o0 && ((gestureDetector = this.q0) == null || gestureDetector.onTouchEvent(motionEvent))) {
            this.m0 = false;
            this.n0 = false;
            this.p0 = 0;
            return true;
        }
        if (this.U == null) {
            this.U = new PointF(0.0f, 0.0f);
        }
        if (this.V == null) {
            this.V = new PointF(0.0f, 0.0f);
        }
        if (this.v0 == null) {
            this.v0 = new PointF(0.0f, 0.0f);
        }
        float f2 = this.R;
        this.V.set(this.T);
        boolean v0 = v0(motionEvent);
        H0(f2, this.V, 2);
        if (motionEvent.getAction() == 0 && (eVar = this.Z0) != null) {
            eVar.B();
        }
        int x = (int) motionEvent.getX();
        int y = (int) motionEvent.getY();
        int action = motionEvent.getAction();
        if (action == 0) {
            this.T0 = System.currentTimeMillis();
            this.U0 = x;
            this.V0 = y;
            this.W0 = false;
        } else if (action == 1) {
            boolean z = System.currentTimeMillis() - this.T0 >= ((long) ViewConfiguration.getLongPressTimeout());
            if (!this.W0 && !z) {
                RectF rectF = new RectF(this.R0 / 5.0f, this.S0 / 3.0f, (r8 * 4) / 5.0f, (r11 * 2) / 3.0f);
                this.X0 = rectF;
                float f3 = x;
                if (rectF.contains(f3, y)) {
                    if (this.Z0 != null) {
                        E0(1);
                    }
                    return true;
                }
                if (f3 < this.R0 / 5.0f) {
                    if (k0()) {
                        E0(3);
                    } else {
                        E0(2);
                    }
                } else if (f3 > (r4 * 4) / 5.0f) {
                    E0(3);
                }
            }
            boolean z2 = this.W0;
        } else if (action == 2) {
            int scaledTouchSlop = this.Q0.getScaledTouchSlop();
            if (!this.W0) {
                float f4 = scaledTouchSlop;
                this.W0 = Math.abs(((float) this.U0) - motionEvent.getX()) > f4 || Math.abs(((float) this.V0) - motionEvent.getY()) > f4;
            }
            boolean z3 = this.W0;
        }
        return v0 || super.onTouchEvent(motionEvent);
    }

    public void p0() {
    }

    public final synchronized void q0(Bitmap bitmap, int i2, boolean z) {
        V("onImageLoaded", new Object[0]);
        if (this.g0 > 0 && this.h0 > 0 && (this.g0 != bitmap.getWidth() || this.h0 != bitmap.getHeight())) {
            B0(false);
        }
        if (this.v != null && !this.x) {
            this.v.recycle();
        }
        if (this.v != null && this.x && this.F0 != null) {
            this.F0.d();
        }
        this.w = false;
        this.x = z;
        this.v = bitmap;
        this.g0 = bitmap.getWidth();
        this.h0 = bitmap.getHeight();
        this.i0 = i2;
        boolean T = T();
        boolean S = S();
        if (T || S) {
            invalidate();
            requestLayout();
        }
    }

    public final synchronized void r0(Bitmap bitmap) {
        V("onPreviewLoaded", new Object[0]);
        if (this.v == null && !this.E0) {
            if (this.l0 != null) {
                this.v = Bitmap.createBitmap(bitmap, this.l0.left, this.l0.top, this.l0.width(), this.l0.height());
            } else {
                this.v = bitmap;
            }
            this.w = true;
            if (T()) {
                invalidate();
                requestLayout();
            }
            return;
        }
        bitmap.recycle();
    }

    public void s0() {
    }

    public final void setBitmapDecoderClass(@NonNull Class<? extends f.p.c.k.n.a.c> cls) {
        if (cls == null) {
            throw new IllegalArgumentException("Decoder class cannot be set to null");
        }
        this.t0 = new f.p.c.k.n.a.a(cls);
    }

    public final void setBitmapDecoderFactory(@NonNull f.p.c.k.n.a.b<? extends f.p.c.k.n.a.c> bVar) {
        if (bVar == null) {
            throw new IllegalArgumentException("Decoder factory cannot be set to null");
        }
        this.t0 = bVar;
    }

    public final void setDebug(boolean z) {
        this.B = z;
    }

    public final void setDoubleTapZoomDpi(int i2) {
        DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        setDoubleTapZoomScale(((displayMetrics.xdpi + displayMetrics.ydpi) / 2.0f) / i2);
    }

    public final void setDoubleTapZoomDuration(int i2) {
        this.Q = Math.max(0, i2);
    }

    public final void setDoubleTapZoomScale(float f2) {
        this.O = f2;
    }

    public final void setDoubleTapZoomStyle(int i2) {
        if (e1.contains(Integer.valueOf(i2))) {
            this.P = i2;
            return;
        }
        throw new IllegalArgumentException("Invalid zoom style: " + i2);
    }

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

    public void setExecutor(@NonNull Executor executor) {
        if (executor == null) {
            throw new NullPointerException("Executor must not be null");
        }
        this.J = executor;
    }

    public final void setImage(@NonNull f.p.c.k.n.b.a aVar) {
        J0(aVar, null, null);
    }

    public final void setMaxScale(float f2) {
        this.D = f2;
    }

    public void setMaxTileSize(int i2) {
        this.H = i2;
        this.I = i2;
    }

    public final void setMaximumDpi(int i2) {
        DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        setMinScale(((displayMetrics.xdpi + displayMetrics.ydpi) / 2.0f) / i2);
    }

    public final void setMinScale(float f2) {
        this.j0 = f2;
    }

    public final void setMinimumDpi(int i2) {
        DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        setMaxScale(((displayMetrics.xdpi + displayMetrics.ydpi) / 2.0f) / i2);
    }

    public final void setMinimumScaleType(int i2) {
        if (!h1.contains(Integer.valueOf(i2))) {
            throw new IllegalArgumentException("Invalid scale type: " + i2);
        }
        this.G = i2;
        if (l0()) {
            d0(true);
            invalidate();
        }
    }

    public void setMinimumTileDpi(int i2) {
        DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        this.E = (int) Math.min((displayMetrics.xdpi + displayMetrics.ydpi) / 2.0f, i2);
        if (l0()) {
            B0(false);
            invalidate();
        }
    }

    public void setOnImageEventListener(j jVar) {
        this.F0 = jVar;
    }

    @Override
    public void setOnLongClickListener(View.OnLongClickListener onLongClickListener) {
        this.H0 = onLongClickListener;
    }

    public void setOnStateChangedListener(k kVar) {
        this.G0 = kVar;
    }

    public final void setOrientation(int i2) {
        if (!d1.contains(Integer.valueOf(i2))) {
            throw new IllegalArgumentException("Invalid orientation: " + i2);
        }
        this.C = i2;
        B0(false);
        invalidate();
        requestLayout();
    }

    public final void setPanEnabled(boolean z) {
        PointF pointF;
        this.L = z;
        if (z || (pointF = this.T) == null) {
            return;
        }
        pointF.x = (getWidth() / 2) - (this.R * (G0() / 2));
        this.T.y = (getHeight() / 2) - (this.R * (F0() / 2));
        if (l0()) {
            z0(true);
            invalidate();
        }
    }

    public final void setPanLimit(int i2) {
        if (!g1.contains(Integer.valueOf(i2))) {
            throw new IllegalArgumentException("Invalid pan limit: " + i2);
        }
        this.F = i2;
        if (l0()) {
            d0(true);
            invalidate();
        }
    }

    public final void setQuickScaleEnabled(boolean z) {
        this.N = z;
    }

    public void setReadOneHandMode(h hVar) {
        this.P0 = hVar;
    }

    public final void setRegionDecoderClass(@NonNull Class<? extends f.p.c.k.n.a.d> cls) {
        if (cls == null) {
            throw new IllegalArgumentException("Decoder class cannot be set to null");
        }
        this.u0 = new f.p.c.k.n.a.a(cls);
    }

    public final void setRegionDecoderFactory(@NonNull f.p.c.k.n.a.b<? extends f.p.c.k.n.a.d> bVar) {
        if (bVar == null) {
            throw new IllegalArgumentException("Decoder factory cannot be set to null");
        }
        this.u0 = bVar;
    }

    public final void setTileBackgroundColor(int i2) {
        if (Color.alpha(i2) == 0) {
            this.L0 = null;
        } else {
            Paint paint = new Paint();
            this.L0 = paint;
            paint.setStyle(Paint.Style.FILL);
            this.L0.setColor(i2);
        }
        invalidate();
    }

    public void setTouchListener(f.p.c.c0.e eVar) {
        this.Z0 = eVar;
    }

    public final void setZoomEnabled(boolean z) {
        this.M = z;
    }

    public final synchronized void t0() {
        V("onTileLoaded", new Object[0]);
        T();
        S();
        if (j0() && this.v != null) {
            if (!this.x) {
                this.v.recycle();
            }
            this.v = null;
            if (this.F0 != null && this.x) {
                this.F0.d();
            }
            this.w = false;
            this.x = false;
        }
        invalidate();
    }

    public final synchronized void u0(f.p.c.k.n.a.d dVar, int i2, int i3, int i4) {
        V("onTilesInited sWidth=%d, sHeight=%d, sOrientation=%d", Integer.valueOf(i2), Integer.valueOf(i3), Integer.valueOf(this.C));
        if (this.g0 > 0 && this.h0 > 0 && (this.g0 != i2 || this.h0 != i3)) {
            B0(false);
            if (this.v != null) {
                if (!this.x) {
                    this.v.recycle();
                }
                this.v = null;
                if (this.F0 != null && this.x) {
                    this.F0.d();
                }
                this.w = false;
                this.x = false;
            }
        }
        this.s0 = dVar;
        this.g0 = i2;
        this.h0 = i3;
        this.i0 = i4;
        T();
        if (!S() && this.H > 0 && this.H != Integer.MAX_VALUE && this.I > 0 && this.I != Integer.MAX_VALUE && getWidth() > 0 && getHeight() > 0) {
            h0(new Point(this.H, this.I));
        }
        invalidate();
        requestLayout();
    }

    public final boolean v0(@androidx.annotation.NonNull android.view.MotionEvent r13) {
        throw new UnsupportedOperationException("Method not decompiled: com.junyue.basic.glide.view.helper.SubsamplingScaleImageViewDragClose.v0(android.view.MotionEvent):boolean");
    }

    public final void w0() {
        Float f2;
        if (getWidth() == 0 || getHeight() == 0 || this.g0 <= 0 || this.h0 <= 0) {
            return;
        }
        if (this.e0 != null && (f2 = this.W) != null) {
            this.R = f2.floatValue();
            if (this.T == null) {
                this.T = new PointF();
            }
            this.T.x = (getWidth() / 2) - (this.R * this.e0.x);
            this.T.y = (getHeight() / 2) - (this.R * this.e0.y);
            this.e0 = null;
            this.W = null;
            d0(true);
            z0(true);
        }
        d0(false);
    }

    public final int x0(int i2) {
        return (int) (this.s * i2);
    }

    public void y0() {
        B0(true);
        this.I0 = null;
        this.J0 = null;
        this.K0 = null;
        this.L0 = null;
    }

    public final void z0(boolean z) {
        if (this.s0 == null || this.A == null) {
            return;
        }
        int min = Math.min(this.z, R(this.R));
        Iterator<Map.Entry<Integer, List<m>>> it = this.A.entrySet().iterator();
        while (it.hasNext()) {
            for (m mVar : it.next().getValue()) {
                if (mVar.b < min || (mVar.b > min && mVar.b != this.z)) {
                    mVar.e = false;
                    if (mVar.c != null) {
                        mVar.c.recycle();
                        mVar.c = null;
                    }
                }
                if (mVar.b == min) {
                    if (R0(mVar)) {
                        mVar.e = true;
                        if (!mVar.d && mVar.c == null && z) {
                            b0(new n(this, this.s0, mVar));
                        }
                    } else if (mVar.b != this.z) {
                        mVar.e = false;
                        if (mVar.c != null) {
                            mVar.c.recycle();
                            mVar.c = null;
                        }
                    }
                } else if (mVar.b == this.z) {
                    mVar.e = true;
                }
            }
        }
    }

    public static class e {
        public float a;
        public float b;
        public PointF c;
        public PointF d;
        public PointF e;

        public PointF f18f;

        public PointF f19g;
        public long h;
        public boolean i;
        public int j;
        public int k;
        public long l;
        public i m;

        public e() {
            this.h = 500L;
            this.i = true;
            this.j = 2;
            this.k = 1;
            this.l = System.currentTimeMillis();
        }

        public e(a aVar) {
            this();
        }
    }
}