package androidx.core.view;

import android.app.Activity;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.res.ColorStateList;
import android.content.res.TypedArray;
import android.graphics.PorterDuff;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.util.SparseArray;
import android.view.ContentInfo;
import android.view.Display;
import android.view.KeyEvent;
import android.view.PointerIcon;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.ViewTreeObserver;
import android.view.Window;
import android.view.WindowInsets;
import android.view.WindowInsetsController;
import android.view.accessibility.AccessibilityEvent;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsAnimationCompat;
import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
import androidx.core.view.accessibility.AccessibilityViewCommand;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import o.C0912RjT;
import o.C16217mQa;
import o.HVe;
import o.KtR;
import o.LbT;
import o.irq;
import o.xsq;
import o.yZt;

/* loaded from: classes.dex */
public class ViewCompat {
    private static Field a;
    private static final AtomicInteger i = new AtomicInteger(1);
    private static WeakHashMap<View, ViewPropertyAnimatorCompat> h = null;
    private static boolean d = false;
    private static final int[] c = {KtR.Sts.accessibility_custom_action_0, KtR.Sts.accessibility_custom_action_1, KtR.Sts.accessibility_custom_action_2, KtR.Sts.accessibility_custom_action_3, KtR.Sts.accessibility_custom_action_4, KtR.Sts.accessibility_custom_action_5, KtR.Sts.accessibility_custom_action_6, KtR.Sts.accessibility_custom_action_7, KtR.Sts.accessibility_custom_action_8, KtR.Sts.accessibility_custom_action_9, KtR.Sts.accessibility_custom_action_10, KtR.Sts.accessibility_custom_action_11, KtR.Sts.accessibility_custom_action_12, KtR.Sts.accessibility_custom_action_13, KtR.Sts.accessibility_custom_action_14, KtR.Sts.accessibility_custom_action_15, KtR.Sts.accessibility_custom_action_16, KtR.Sts.accessibility_custom_action_17, KtR.Sts.accessibility_custom_action_18, KtR.Sts.accessibility_custom_action_19, KtR.Sts.accessibility_custom_action_20, KtR.Sts.accessibility_custom_action_21, KtR.Sts.accessibility_custom_action_22, KtR.Sts.accessibility_custom_action_23, KtR.Sts.accessibility_custom_action_24, KtR.Sts.accessibility_custom_action_25, KtR.Sts.accessibility_custom_action_26, KtR.Sts.accessibility_custom_action_27, KtR.Sts.accessibility_custom_action_28, KtR.Sts.accessibility_custom_action_29, KtR.Sts.accessibility_custom_action_30, KtR.Sts.accessibility_custom_action_31};
    private static final xsq e = new xsq() { // from class: o.Bse
        @Override // o.xsq
        public final irq a(irq irqVar) {
            return ViewCompat.b(irqVar);
        }
    };
    private static final IeS b = new IeS();

    /* loaded from: classes.dex */
    public interface OnUnhandledKeyEventListenerCompat {
        boolean sK_(View view, KeyEvent keyEvent);
    }

    public static /* synthetic */ irq b(irq irqVar) {
        return irqVar;
    }

    public static void sm_(View view, Context context, int[] iArr, AttributeSet attributeSet, TypedArray typedArray, int i2, int i3) {
        if (Build.VERSION.SDK_INT >= 29) {
            vUG.sJ_(view, context, iArr, attributeSet, typedArray, i2, i3);
        }
    }

    public static void e(View view, AccessibilityNodeInfoCompat accessibilityNodeInfoCompat) {
        view.onInitializeAccessibilityNodeInfo(accessibilityNodeInfoCompat.ub_());
    }

    public static void e(View view, yZt yzt) {
        if (yzt == null && (sf_(view) instanceof yZt.IeS)) {
            yzt = new yZt();
        }
        view.setAccessibilityDelegate(yzt == null ? null : yzt.getBridge());
    }

    public static int k(View view) {
        return jNh.b(view);
    }

    public static void j(View view, int i2) {
        jNh.b(view, i2);
    }

    public static boolean D(View view) {
        return sf_(view) != null;
    }

    public static yZt c(View view) {
        View.AccessibilityDelegate sf_ = sf_(view);
        if (sf_ == null) {
            return null;
        }
        if (sf_ instanceof yZt.IeS) {
            return ((yZt.IeS) sf_).d;
        }
        return new yZt(sf_);
    }

    static void d(View view) {
        yZt c2 = c(view);
        if (c2 == null) {
            c2 = new yZt();
        }
        e(view, c2);
    }

    private static View.AccessibilityDelegate sf_(View view) {
        if (Build.VERSION.SDK_INT >= 29) {
            return vUG.sI_(view);
        }
        return sg_(view);
    }

    private static View.AccessibilityDelegate sg_(View view) {
        if (d) {
            return null;
        }
        if (a == null) {
            try {
                Field declaredField = View.class.getDeclaredField("mAccessibilityDelegate");
                a = declaredField;
                declaredField.setAccessible(true);
            } catch (Throwable unused) {
                d = true;
                return null;
            }
        }
        try {
            Object obj = a.get(view);
            if (obj instanceof View.AccessibilityDelegate) {
                return (View.AccessibilityDelegate) obj;
            }
            return null;
        } catch (Throwable unused2) {
            d = true;
            return null;
        }
    }

    public static boolean z(View view) {
        return RVV.j(view);
    }

    public static void b(View view, boolean z) {
        RVV.d(view, z);
    }

    public static void N(View view) {
        RVV.i(view);
    }

    public static void e(View view, Runnable runnable) {
        RVV.d(view, runnable);
    }

    public static void b(View view, Runnable runnable, long j) {
        RVV.d(view, runnable, j);
    }

    public static int n(View view) {
        return RVV.b(view);
    }

    public static void g(View view, int i2) {
        RVV.a(view, i2);
    }

    public static boolean sl_(View view, int i2, Bundle bundle) {
        return RVV.sr_(view, i2, bundle);
    }

    public static int a(View view, CharSequence charSequence, AccessibilityViewCommand accessibilityViewCommand) {
        int a2 = a(view, charSequence);
        if (a2 != -1) {
            d(view, new AccessibilityNodeInfoCompat.AccessibilityActionCompat(a2, charSequence, accessibilityViewCommand));
        }
        return a2;
    }

    private static int a(View view, CharSequence charSequence) {
        List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> P = P(view);
        for (int i2 = 0; i2 < P.size(); i2++) {
            if (TextUtils.equals(charSequence, P.get(i2).b())) {
                return P.get(i2).c();
            }
        }
        int i3 = -1;
        int i4 = 0;
        while (true) {
            int[] iArr = c;
            if (i4 >= iArr.length || i3 != -1) {
                break;
            }
            int i5 = iArr[i4];
            boolean z = true;
            for (int i6 = 0; i6 < P.size(); i6++) {
                z &= P.get(i6).c() != i5;
            }
            if (z) {
                i3 = i5;
            }
            i4++;
        }
        return i3;
    }

    public static void a(View view, AccessibilityNodeInfoCompat.AccessibilityActionCompat accessibilityActionCompat, CharSequence charSequence, AccessibilityViewCommand accessibilityViewCommand) {
        if (accessibilityViewCommand == null && charSequence == null) {
            b(view, accessibilityActionCompat.c());
        } else {
            d(view, accessibilityActionCompat.d(charSequence, accessibilityViewCommand));
        }
    }

    private static void d(View view, AccessibilityNodeInfoCompat.AccessibilityActionCompat accessibilityActionCompat) {
        d(view);
        e(accessibilityActionCompat.c(), view);
        P(view).add(accessibilityActionCompat);
        a(view, 0);
    }

    public static void b(View view, int i2) {
        e(i2, view);
        a(view, 0);
    }

    private static void e(int i2, View view) {
        List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> P = P(view);
        for (int i3 = 0; i3 < P.size(); i3++) {
            if (P.get(i3).c() == i2) {
                P.remove(i3);
                return;
            }
        }
    }

    private static List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> P(View view) {
        ArrayList arrayList = (ArrayList) view.getTag(KtR.Sts.tag_accessibility_actions);
        if (arrayList != null) {
            return arrayList;
        }
        ArrayList arrayList2 = new ArrayList();
        view.setTag(KtR.Sts.tag_accessibility_actions, arrayList2);
        return arrayList2;
    }

    public static void e(View view, CharSequence charSequence) {
        c().e(view, (View) charSequence);
    }

    public static CharSequence x(View view) {
        return c().e(view);
    }

    public static void i(View view, int i2) {
        Sts.a(view, i2);
    }

    public static int m(View view) {
        return Sts.a(view);
    }

    public static int a(View view) {
        return jbe.d(view);
    }

    public static void c(View view, int i2) {
        jbe.a(view, i2);
    }

    public static int q(View view) {
        return Sts.d(view);
    }

    public static int r(View view) {
        return Sts.e(view);
    }

    public static void a(View view, int i2, int i3, int i4, int i5) {
        Sts.e(view, i2, i3, i4, i5);
    }

    public static int p(View view) {
        return RVV.e(view);
    }

    public static int o(View view) {
        return RVV.a(view);
    }

    public static ViewPropertyAnimatorCompat b(View view) {
        if (h == null) {
            h = new WeakHashMap<>();
        }
        ViewPropertyAnimatorCompat viewPropertyAnimatorCompat = h.get(view);
        if (viewPropertyAnimatorCompat != null) {
            return viewPropertyAnimatorCompat;
        }
        ViewPropertyAnimatorCompat viewPropertyAnimatorCompat2 = new ViewPropertyAnimatorCompat(view);
        h.put(view, viewPropertyAnimatorCompat2);
        return viewPropertyAnimatorCompat2;
    }

    public static void e(View view, float f) {
        ojQ.c(view, f);
    }

    public static float i(View view) {
        return ojQ.b(view);
    }

    public static void a(View view, float f) {
        ojQ.b(view, f);
    }

    public static float v(View view) {
        return ojQ.d(view);
    }

    public static void a(View view, String str) {
        ojQ.b(view, str);
    }

    public static String u(View view) {
        return ojQ.a(view);
    }

    @Deprecated
    public static int w(View view) {
        return RVV.c(view);
    }

    public static void J(View view) {
        ZqN.a(view);
    }

    public static boolean l(View view) {
        return RVV.d(view);
    }

    @Deprecated
    public static void a(View view, boolean z) {
        view.setFitsSystemWindows(z);
    }

    public static void c(View view, LbT lbT) {
        ojQ.a(view, lbT);
    }

    public static WindowInsetsCompat e(View view, WindowInsetsCompat windowInsetsCompat) {
        WindowInsets tI_ = windowInsetsCompat.tI_();
        if (tI_ != null) {
            WindowInsets sA_ = ZqN.sA_(view, tI_);
            if (!sA_.equals(tI_)) {
                return WindowInsetsCompat.tH_(sA_, view);
            }
        }
        return windowInsetsCompat;
    }

    public static WindowInsetsCompat b(View view, WindowInsetsCompat windowInsetsCompat) {
        WindowInsets tI_ = windowInsetsCompat.tI_();
        if (tI_ != null) {
            WindowInsets sz_ = ZqN.sz_(view, tI_);
            if (!sz_.equals(tI_)) {
                return WindowInsetsCompat.tH_(sz_, view);
            }
        }
        return windowInsetsCompat;
    }

    public static WindowInsetsCompat t(View view) {
        return saX.d(view);
    }

    public static WindowInsetsCompat sc_(View view, WindowInsetsCompat windowInsetsCompat, Rect rect) {
        return ojQ.sC_(view, windowInsetsCompat, rect);
    }

    @Deprecated
    public static WindowInsetsControllerCompat y(View view) {
        if (Build.VERSION.SDK_INT >= 30) {
            return dAO.c(view);
        }
        for (Context context = view.getContext(); context instanceof ContextWrapper; context = ((ContextWrapper) context).getBaseContext()) {
            if (context instanceof Activity) {
                Window window = ((Activity) context).getWindow();
                if (window != null) {
                    return C16217mQa.ts_(window, view);
                }
                return null;
            }
        }
        return null;
    }

    public static void d(View view, WindowInsetsAnimationCompat.Callback callback) {
        WindowInsetsAnimationCompat.b(view, callback);
    }

    public static String[] s(View view) {
        if (Build.VERSION.SDK_INT >= 31) {
            return huo.c(view);
        }
        return (String[]) view.getTag(KtR.Sts.tag_on_receive_content_mime_types);
    }

    public static irq c(View view, irq irqVar) {
        if (Log.isLoggable("ViewCompat", 3)) {
            view.getId();
        }
        if (Build.VERSION.SDK_INT >= 31) {
            return huo.e(view, irqVar);
        }
        HVe hVe = (HVe) view.getTag(KtR.Sts.tag_on_receive_content_listener);
        if (hVe != null) {
            irq e2 = hVe.e(view, irqVar);
            if (e2 == null) {
                return null;
            }
            return R(view).a(e2);
        }
        return R(view).a(irqVar);
    }

    /* JADX WARN: Multi-variable type inference failed */
    private static xsq R(View view) {
        return view instanceof xsq ? (xsq) view : e;
    }

    /* loaded from: classes.dex */
    static final class huo {
        public static String[] c(View view) {
            return view.getReceiveContentMimeTypes();
        }

        public static irq e(View view, irq irqVar) {
            ContentInfo qU_ = irqVar.qU_();
            ContentInfo performReceiveContent = view.performReceiveContent(qU_);
            if (performReceiveContent == null) {
                return null;
            }
            return performReceiveContent == qU_ ? irqVar : irq.qS_(performReceiveContent);
        }
    }

    public static boolean A(View view) {
        return RVV.f(view);
    }

    public static boolean E(View view) {
        return Sts.c(view);
    }

    public static void sn_(View view, Drawable drawable) {
        RVV.st_(view, drawable);
    }

    public static ColorStateList sh_(View view) {
        return ojQ.sD_(view);
    }

    public static void so_(View view, ColorStateList colorStateList) {
        ojQ.sF_(view, colorStateList);
    }

    public static PorterDuff.Mode si_(View view) {
        return ojQ.sE_(view);
    }

    public static void sp_(View view, PorterDuff.Mode mode) {
        ojQ.sG_(view, mode);
    }

    public static void d(View view, boolean z) {
        ojQ.c(view, z);
    }

    public static boolean I(View view) {
        return ojQ.h(view);
    }

    public static void K(View view) {
        ojQ.i(view);
    }

    public static boolean G(View view) {
        return jbe.e(view);
    }

    public static float C(View view) {
        return ojQ.j(view);
    }

    public static void d(View view, int i2) {
        view.offsetTopAndBottom(i2);
    }

    public static void e(View view, int i2) {
        view.offsetLeftAndRight(i2);
    }

    public static void sq_(View view, Rect rect) {
        tOB.sw_(view, rect);
    }

    public static Rect sj_(View view) {
        return tOB.sv_(view);
    }

    public static boolean H(View view) {
        return jbe.c(view);
    }

    public static boolean B(View view) {
        return HBt.c(view);
    }

    public static void e(View view, int i2, int i3) {
        saX.a(view, i2, i3);
    }

    public static void d(View view, C0912RjT c0912RjT) {
        ZnX.sH_(view, (PointerIcon) (c0912RjT != null ? c0912RjT.e() : null));
    }

    public static Display sk_(View view) {
        return Sts.su_(view);
    }

    public static int a() {
        return Sts.d();
    }

    @Deprecated
    protected ViewCompat() {
    }

    public static boolean se_(View view, KeyEvent keyEvent) {
        if (Build.VERSION.SDK_INT >= 28) {
            return false;
        }
        return Heg.d(view).sP_(keyEvent);
    }

    public static boolean sd_(View view, KeyEvent keyEvent) {
        if (Build.VERSION.SDK_INT >= 28) {
            return false;
        }
        return Heg.d(view).sO_(view, keyEvent);
    }

    public static void e(View view, boolean z) {
        e().e(view, (View) Boolean.valueOf(z));
    }

    public static boolean L(View view) {
        Boolean e2 = e().e(view);
        return e2 != null && e2.booleanValue();
    }

    private static LWm<Boolean> e() {
        return new LWm<Boolean>(KtR.Sts.tag_screen_reader_focusable, Boolean.class, 28) { // from class: androidx.core.view.ViewCompat.1
            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: b, reason: merged with bridge method [inline-methods] */
            public Boolean c(View view) {
                return Boolean.valueOf(NHB.e(view));
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: b, reason: merged with bridge method [inline-methods] */
            public void d(View view, Boolean bool) {
                NHB.e(view, bool.booleanValue());
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            public boolean e(Boolean bool, Boolean bool2) {
                return !a(bool, bool2);
            }
        };
    }

    public static void d(View view, CharSequence charSequence) {
        d().e(view, (View) charSequence);
        if (charSequence != null) {
            b.e(view);
        } else {
            b.c(view);
        }
    }

    public static CharSequence e(View view) {
        return d().e(view);
    }

    private static LWm<CharSequence> d() {
        return new LWm<CharSequence>(KtR.Sts.tag_accessibility_pane_title, CharSequence.class, 8, 28) { // from class: androidx.core.view.ViewCompat.2
            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: a, reason: merged with bridge method [inline-methods] */
            public CharSequence c(View view) {
                return NHB.b(view);
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: a, reason: merged with bridge method [inline-methods] */
            public void d(View view, CharSequence charSequence) {
                NHB.e(view, charSequence);
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            public boolean e(CharSequence charSequence, CharSequence charSequence2) {
                return !TextUtils.equals(charSequence, charSequence2);
            }
        };
    }

    private static LWm<CharSequence> c() {
        return new LWm<CharSequence>(KtR.Sts.tag_state_description, CharSequence.class, 64, 30) { // from class: androidx.core.view.ViewCompat.3
            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: b, reason: merged with bridge method [inline-methods] */
            public CharSequence c(View view) {
                return dAO.d(view);
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: a, reason: merged with bridge method [inline-methods] */
            public void d(View view, CharSequence charSequence) {
                dAO.e(view, charSequence);
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: d, reason: merged with bridge method [inline-methods] */
            public boolean e(CharSequence charSequence, CharSequence charSequence2) {
                return !TextUtils.equals(charSequence, charSequence2);
            }
        };
    }

    public static boolean F(View view) {
        Boolean e2 = b().e(view);
        return e2 != null && e2.booleanValue();
    }

    public static void c(View view, boolean z) {
        b().e(view, (View) Boolean.valueOf(z));
    }

    private static LWm<Boolean> b() {
        return new LWm<Boolean>(KtR.Sts.tag_accessibility_heading, Boolean.class, 28) { // from class: androidx.core.view.ViewCompat.5
            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: b, reason: merged with bridge method [inline-methods] */
            public Boolean c(View view) {
                return Boolean.valueOf(NHB.a(view));
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: e, reason: merged with bridge method [inline-methods] */
            public void d(View view, Boolean bool) {
                NHB.d(view, bool.booleanValue());
            }

            /* JADX INFO: Access modifiers changed from: package-private */
            @Override // androidx.core.view.ViewCompat.LWm
            /* renamed from: c, reason: merged with bridge method [inline-methods] */
            public boolean e(Boolean bool, Boolean bool2) {
                return !a(bool, bool2);
            }
        };
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static abstract class LWm<T> {
        private final int a;
        private final int b;
        private final int c;
        private final Class<T> e;

        private boolean b() {
            return true;
        }

        abstract T c(View view);

        abstract void d(View view, T t);

        LWm(int i, Class<T> cls, int i2) {
            this(i, cls, 0, i2);
        }

        LWm(int i, Class<T> cls, int i2, int i3) {
            this.c = i;
            this.e = cls;
            this.a = i2;
            this.b = i3;
        }

        void e(View view, T t) {
            if (c()) {
                d(view, t);
            } else if (b() && e(e(view), t)) {
                ViewCompat.d(view);
                view.setTag(this.c, t);
                ViewCompat.a(view, this.a);
            }
        }

        T e(View view) {
            if (c()) {
                return c(view);
            }
            if (!b()) {
                return null;
            }
            T t = (T) view.getTag(this.c);
            if (this.e.isInstance(t)) {
                return t;
            }
            return null;
        }

        boolean e(T t, T t2) {
            return !t2.equals(t);
        }

        boolean a(Boolean bool, Boolean bool2) {
            return (bool != null && bool.booleanValue()) == (bool2 != null && bool2.booleanValue());
        }

        private boolean c() {
            return Build.VERSION.SDK_INT >= this.b;
        }
    }

    static void a(View view, int i2) {
        Object systemService = view.getContext().getSystemService("accessibility");
        try {
            if (((Boolean) Class.forName("android.view.accessibility.AccessibilityManager").getMethod("isEnabled", null).invoke(systemService, null)).booleanValue()) {
                boolean z = e(view) != null && view.isShown() && view.getWindowVisibility() == 0;
                if (a(view) != 0 || z) {
                    AccessibilityEvent obtain = AccessibilityEvent.obtain();
                    obtain.setEventType(z ? 32 : 2048);
                    jbe.sy_(obtain, i2);
                    if (z) {
                        obtain.getText().add(e(view));
                        S(view);
                    }
                    view.sendAccessibilityEventUnchecked(obtain);
                    return;
                }
                if (i2 == 32) {
                    AccessibilityEvent obtain2 = AccessibilityEvent.obtain();
                    view.onInitializeAccessibilityEvent(obtain2);
                    obtain2.setEventType(32);
                    jbe.sy_(obtain2, i2);
                    obtain2.setSource(view);
                    view.onPopulateAccessibilityEvent(obtain2);
                    obtain2.getText().add(e(view));
                    Class.forName("android.view.accessibility.AccessibilityManager").getMethod("sendAccessibilityEvent", AccessibilityEvent.class).invoke(systemService, obtain2);
                    return;
                }
                if (view.getParent() != null) {
                    try {
                        jbe.sx_(view.getParent(), view, view, i2);
                    } catch (AbstractMethodError unused) {
                        view.getParent();
                    }
                }
            }
        } catch (Throwable th) {
            Throwable cause = th.getCause();
            if (cause == null) {
                throw th;
            }
            throw cause;
        }
    }

    private static void S(View view) {
        if (n(view) == 0) {
            g(view, 1);
        }
        for (ViewParent parent = view.getParent(); parent instanceof View; parent = parent.getParent()) {
            if (n((View) parent) == 4) {
                g(view, 2);
                return;
            }
        }
    }

    /* loaded from: classes.dex */
    static class IeS implements ViewTreeObserver.OnGlobalLayoutListener, View.OnAttachStateChangeListener {
        private final WeakHashMap<View, Boolean> a = new WeakHashMap<>();

        @Override // android.view.View.OnAttachStateChangeListener
        public void onViewDetachedFromWindow(View view) {
        }

        IeS() {
        }

        @Override // android.view.ViewTreeObserver.OnGlobalLayoutListener
        public void onGlobalLayout() {
            if (Build.VERSION.SDK_INT < 28) {
                for (Map.Entry<View, Boolean> entry : this.a.entrySet()) {
                    e(entry.getKey(), entry.getValue().booleanValue());
                }
            }
        }

        @Override // android.view.View.OnAttachStateChangeListener
        public void onViewAttachedToWindow(View view) {
            a(view);
        }

        void e(View view) {
            this.a.put(view, Boolean.valueOf(view.isShown() && view.getWindowVisibility() == 0));
            view.addOnAttachStateChangeListener(this);
            if (jbe.c(view)) {
                a(view);
            }
        }

        void c(View view) {
            this.a.remove(view);
            view.removeOnAttachStateChangeListener(this);
            b(view);
        }

        private void e(View view, boolean z) {
            boolean z2 = view.isShown() && view.getWindowVisibility() == 0;
            if (z != z2) {
                ViewCompat.a(view, z2 ? 16 : 32);
                this.a.put(view, Boolean.valueOf(z2));
            }
        }

        private void a(View view) {
            view.getViewTreeObserver().addOnGlobalLayoutListener(this);
        }

        private void b(View view) {
            RVV.ss_(view.getViewTreeObserver(), this);
        }
    }

    /* loaded from: classes.dex */
    static class Heg {
        private static final ArrayList<WeakReference<View>> b = new ArrayList<>();
        private WeakHashMap<View, Boolean> a = null;
        private SparseArray<WeakReference<View>> d = null;
        private WeakReference<KeyEvent> e = null;

        Heg() {
        }

        private SparseArray<WeakReference<View>> sM_() {
            if (this.d == null) {
                this.d = new SparseArray<>();
            }
            return this.d;
        }

        static Heg d(View view) {
            Heg heg = (Heg) view.getTag(KtR.Sts.tag_unhandled_key_event_manager);
            if (heg != null) {
                return heg;
            }
            Heg heg2 = new Heg();
            view.setTag(KtR.Sts.tag_unhandled_key_event_manager, heg2);
            return heg2;
        }

        boolean sO_(View view, KeyEvent keyEvent) {
            if (keyEvent.getAction() == 0) {
                c();
            }
            View sL_ = sL_(view, keyEvent);
            if (keyEvent.getAction() == 0) {
                int keyCode = keyEvent.getKeyCode();
                if (sL_ != null && !KeyEvent.isModifierKey(keyCode)) {
                    sM_().put(keyCode, new WeakReference<>(sL_));
                }
            }
            return sL_ != null;
        }

        private View sL_(View view, KeyEvent keyEvent) {
            WeakHashMap<View, Boolean> weakHashMap = this.a;
            if (weakHashMap == null || !weakHashMap.containsKey(view)) {
                return null;
            }
            if (view instanceof ViewGroup) {
                ViewGroup viewGroup = (ViewGroup) view;
                for (int childCount = viewGroup.getChildCount() - 1; childCount >= 0; childCount--) {
                    View sL_ = sL_(viewGroup.getChildAt(childCount), keyEvent);
                    if (sL_ != null) {
                        return sL_;
                    }
                }
            }
            if (sN_(view, keyEvent)) {
                return view;
            }
            return null;
        }

        boolean sP_(KeyEvent keyEvent) {
            WeakReference<View> weakReference;
            int indexOfKey;
            WeakReference<KeyEvent> weakReference2 = this.e;
            if (weakReference2 != null && weakReference2.get() == keyEvent) {
                return false;
            }
            this.e = new WeakReference<>(keyEvent);
            SparseArray<WeakReference<View>> sM_ = sM_();
            if (keyEvent.getAction() != 1 || (indexOfKey = sM_.indexOfKey(keyEvent.getKeyCode())) < 0) {
                weakReference = null;
            } else {
                weakReference = sM_.valueAt(indexOfKey);
                sM_.removeAt(indexOfKey);
            }
            if (weakReference == null) {
                weakReference = sM_.get(keyEvent.getKeyCode());
            }
            if (weakReference == null) {
                return false;
            }
            View view = weakReference.get();
            if (view != null && ViewCompat.H(view)) {
                sN_(view, keyEvent);
            }
            return true;
        }

        private boolean sN_(View view, KeyEvent keyEvent) {
            ArrayList arrayList = (ArrayList) view.getTag(KtR.Sts.tag_unhandled_key_listeners);
            if (arrayList == null) {
                return false;
            }
            for (int size = arrayList.size() - 1; size >= 0; size--) {
                if (((OnUnhandledKeyEventListenerCompat) arrayList.get(size)).sK_(view, keyEvent)) {
                    return true;
                }
            }
            return false;
        }

        private void c() {
            WeakHashMap<View, Boolean> weakHashMap = this.a;
            if (weakHashMap != null) {
                weakHashMap.clear();
            }
            ArrayList<WeakReference<View>> arrayList = b;
            if (arrayList.isEmpty()) {
                return;
            }
            synchronized (arrayList) {
                if (this.a == null) {
                    this.a = new WeakHashMap<>();
                }
                for (int size = arrayList.size() - 1; size >= 0; size--) {
                    ArrayList<WeakReference<View>> arrayList2 = b;
                    View view = arrayList2.get(size).get();
                    if (view == null) {
                        arrayList2.remove(size);
                    } else {
                        this.a.put(view, Boolean.TRUE);
                        for (ViewParent parent = view.getParent(); parent instanceof View; parent = parent.getParent()) {
                            this.a.put((View) parent, Boolean.TRUE);
                        }
                    }
                }
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class ojQ {
        static WindowInsetsCompat sC_(View view, WindowInsetsCompat windowInsetsCompat, Rect rect) {
            WindowInsets tI_ = windowInsetsCompat.tI_();
            if (tI_ != null) {
                return WindowInsetsCompat.tH_(view.computeSystemWindowInsets(tI_, rect), view);
            }
            rect.setEmpty();
            return windowInsetsCompat;
        }

        static void a(View view, LbT lbT) {
            if (Build.VERSION.SDK_INT < 30) {
                view.setTag(KtR.Sts.tag_on_apply_window_listener, lbT);
            }
            if (lbT == null) {
                view.setOnApplyWindowInsetsListener((View.OnApplyWindowInsetsListener) view.getTag(KtR.Sts.tag_window_insets_animation_callback));
            } else {
                view.setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener(view, lbT) { // from class: androidx.core.view.ViewCompat.ojQ.5
                    final LbT a;
                    WindowInsetsCompat b = null;
                    final View c;

                    {
                        this.c = view;
                        this.a = lbT;
                    }

                    @Override // android.view.View.OnApplyWindowInsetsListener
                    public WindowInsets onApplyWindowInsets(View view2, WindowInsets windowInsets) {
                        WindowInsetsCompat tH_ = WindowInsetsCompat.tH_(windowInsets, view2);
                        if (Build.VERSION.SDK_INT < 30) {
                            ojQ.sB_(windowInsets, this.c);
                            if (tH_.equals(this.b)) {
                                return this.a.e(view2, tH_).tI_();
                            }
                        }
                        this.b = tH_;
                        WindowInsetsCompat e = this.a.e(view2, tH_);
                        if (Build.VERSION.SDK_INT >= 30) {
                            return e.tI_();
                        }
                        ViewCompat.J(view2);
                        return e.tI_();
                    }
                });
            }
        }

        static void sB_(WindowInsets windowInsets, View view) {
            View.OnApplyWindowInsetsListener onApplyWindowInsetsListener = (View.OnApplyWindowInsetsListener) view.getTag(KtR.Sts.tag_window_insets_animation_callback);
            if (onApplyWindowInsetsListener != null) {
                onApplyWindowInsetsListener.onApplyWindowInsets(view, windowInsets);
            }
        }

        static float j(View view) {
            return view.getZ();
        }

        static void c(View view, float f) {
            view.setElevation(f);
        }

        static void b(View view, float f) {
            view.setTranslationZ(f);
        }

        static float d(View view) {
            return view.getTranslationZ();
        }

        static void b(View view, String str) {
            view.setTransitionName(str);
        }

        static float b(View view) {
            return view.getElevation();
        }

        static String a(View view) {
            return view.getTransitionName();
        }

        static void sF_(View view, ColorStateList colorStateList) {
            view.setBackgroundTintList(colorStateList);
        }

        static ColorStateList sD_(View view) {
            return view.getBackgroundTintList();
        }

        static PorterDuff.Mode sE_(View view) {
            return view.getBackgroundTintMode();
        }

        static void sG_(View view, PorterDuff.Mode mode) {
            view.setBackgroundTintMode(mode);
        }

        static void c(View view, boolean z) {
            view.setNestedScrollingEnabled(z);
        }

        static boolean h(View view) {
            return view.isNestedScrollingEnabled();
        }

        static void i(View view) {
            view.stopNestedScroll();
        }
    }

    /* loaded from: classes.dex */
    static class saX {
        public static WindowInsetsCompat d(View view) {
            WindowInsets rootWindowInsets = view.getRootWindowInsets();
            if (rootWindowInsets == null) {
                return null;
            }
            WindowInsetsCompat tG_ = WindowInsetsCompat.tG_(rootWindowInsets);
            tG_.c(tG_);
            tG_.d(view.getRootView());
            return tG_;
        }

        static void a(View view, int i, int i2) {
            view.setScrollIndicators(i, i2);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class vUG {
        static void sJ_(View view, Context context, int[] iArr, AttributeSet attributeSet, TypedArray typedArray, int i, int i2) {
            view.saveAttributeDataForStyleable(context, iArr, attributeSet, typedArray, i, i2);
        }

        static View.AccessibilityDelegate sI_(View view) {
            return view.getAccessibilityDelegate();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class dAO {
        public static WindowInsetsControllerCompat c(View view) {
            WindowInsetsController windowInsetsController = view.getWindowInsetsController();
            if (windowInsetsController != null) {
                return WindowInsetsControllerCompat.tK_(windowInsetsController);
            }
            return null;
        }

        static void e(View view, CharSequence charSequence) {
            view.setStateDescription(charSequence);
        }

        static CharSequence d(View view) {
            return view.getStateDescription();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class jNh {
        static int b(View view) {
            return view.getImportantForAutofill();
        }

        static void b(View view, int i) {
            view.setImportantForAutofill(i);
        }
    }

    /* loaded from: classes.dex */
    static class tOB {
        static void sw_(View view, Rect rect) {
            view.setClipBounds(rect);
        }

        static Rect sv_(View view) {
            return view.getClipBounds();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class jbe {
        static boolean e(View view) {
            return view.isLaidOut();
        }

        static boolean c(View view) {
            return view.isAttachedToWindow();
        }

        static int d(View view) {
            return view.getAccessibilityLiveRegion();
        }

        static void a(View view, int i) {
            view.setAccessibilityLiveRegion(i);
        }

        static void sy_(AccessibilityEvent accessibilityEvent, int i) {
            accessibilityEvent.setContentChangeTypes(i);
        }

        static void sx_(ViewParent viewParent, View view, View view2, int i) {
            viewParent.notifySubtreeAccessibilityStateChanged(view, view2, i);
        }
    }

    /* loaded from: classes.dex */
    static class HBt {
        static boolean c(View view) {
            return view.hasOnClickListeners();
        }
    }

    /* loaded from: classes.dex */
    static class ZnX {
        static void sH_(View view, PointerIcon pointerIcon) {
            view.setPointerIcon(pointerIcon);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class Sts {
        static Display su_(View view) {
            return view.getDisplay();
        }

        static int d() {
            return View.generateViewId();
        }

        static void a(View view, int i) {
            view.setLabelFor(i);
        }

        static int a(View view) {
            return view.getLayoutDirection();
        }

        static int d(View view) {
            return view.getPaddingStart();
        }

        static int e(View view) {
            return view.getPaddingEnd();
        }

        static void e(View view, int i, int i2, int i3, int i4) {
            view.setPaddingRelative(i, i2, i3, i4);
        }

        static boolean c(View view) {
            return view.isPaddingRelative();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class RVV {
        static boolean j(View view) {
            return view.hasTransientState();
        }

        static void d(View view, boolean z) {
            view.setHasTransientState(z);
        }

        static void i(View view) {
            view.postInvalidateOnAnimation();
        }

        static void d(View view, Runnable runnable) {
            view.postOnAnimation(runnable);
        }

        static void d(View view, Runnable runnable, long j) {
            view.postOnAnimationDelayed(runnable, j);
        }

        static int b(View view) {
            return view.getImportantForAccessibility();
        }

        static void a(View view, int i) {
            view.setImportantForAccessibility(i);
        }

        static int e(View view) {
            return view.getMinimumWidth();
        }

        static int a(View view) {
            return view.getMinimumHeight();
        }

        static int c(View view) {
            return view.getWindowSystemUiVisibility();
        }

        static boolean d(View view) {
            return view.getFitsSystemWindows();
        }

        static boolean sr_(View view, int i, Bundle bundle) {
            return view.performAccessibilityAction(i, bundle);
        }

        static boolean f(View view) {
            return view.hasOverlappingRendering();
        }

        static void st_(View view, Drawable drawable) {
            view.setBackground(drawable);
        }

        static void ss_(ViewTreeObserver viewTreeObserver, ViewTreeObserver.OnGlobalLayoutListener onGlobalLayoutListener) {
            viewTreeObserver.removeOnGlobalLayoutListener(onGlobalLayoutListener);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class NHB {
        static CharSequence b(View view) {
            return view.getAccessibilityPaneTitle();
        }

        static void e(View view, CharSequence charSequence) {
            view.setAccessibilityPaneTitle(charSequence);
        }

        static void d(View view, boolean z) {
            view.setAccessibilityHeading(z);
        }

        static boolean a(View view) {
            return view.isAccessibilityHeading();
        }

        static boolean e(View view) {
            return view.isScreenReaderFocusable();
        }

        static void e(View view, boolean z) {
            view.setScreenReaderFocusable(z);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public static class ZqN {
        static void a(View view) {
            view.requestApplyInsets();
        }

        static WindowInsets sA_(View view, WindowInsets windowInsets) {
            return view.onApplyWindowInsets(windowInsets);
        }

        static WindowInsets sz_(View view, WindowInsets windowInsets) {
            return view.dispatchApplyWindowInsets(windowInsets);
        }
    }
}