Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/core/view/AccessibilityDelegateCompat.java

@@ -0,0 +1,197 @@
+package androidx.core.view;
+
+import android.os.Bundle;
+import android.text.style.ClickableSpan;
+import android.util.SparseArray;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+import android.view.accessibility.AccessibilityNodeInfo;
+import android.view.accessibility.AccessibilityNodeProvider;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.core.R;
+import androidx.core.view.accessibility.AccessibilityClickableSpanCompat;
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
+import androidx.core.view.accessibility.AccessibilityNodeProviderCompat;
+import java.lang.ref.WeakReference;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class AccessibilityDelegateCompat {
+    private static final View.AccessibilityDelegate DEFAULT_DELEGATE = new View.AccessibilityDelegate();
+    private final View.AccessibilityDelegate mBridge;
+    private final View.AccessibilityDelegate mOriginalDelegate;
+
+    public View.AccessibilityDelegate getBridge() {
+        return this.mBridge;
+    }
+
+    public static final class AccessibilityDelegateAdapter extends View.AccessibilityDelegate {
+        final AccessibilityDelegateCompat mCompat;
+
+        public AccessibilityDelegateAdapter(AccessibilityDelegateCompat accessibilityDelegateCompat) {
+            this.mCompat = accessibilityDelegateCompat;
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public boolean dispatchPopulateAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
+            return this.mCompat.dispatchPopulateAccessibilityEvent(view, accessibilityEvent);
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public void onInitializeAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
+            this.mCompat.onInitializeAccessibilityEvent(view, accessibilityEvent);
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public void onInitializeAccessibilityNodeInfo(View view, AccessibilityNodeInfo accessibilityNodeInfo) {
+            AccessibilityNodeInfoCompat wrap = AccessibilityNodeInfoCompat.wrap(accessibilityNodeInfo);
+            wrap.setScreenReaderFocusable(ViewCompat.isScreenReaderFocusable(view));
+            wrap.setHeading(ViewCompat.isAccessibilityHeading(view));
+            wrap.setPaneTitle(ViewCompat.getAccessibilityPaneTitle(view));
+            wrap.setStateDescription(ViewCompat.getStateDescription(view));
+            this.mCompat.onInitializeAccessibilityNodeInfo(view, wrap);
+            wrap.addSpansToExtras(accessibilityNodeInfo.getText(), view);
+            List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> actionList = AccessibilityDelegateCompat.getActionList(view);
+            for (int i = 0; i < actionList.size(); i++) {
+                wrap.addAction(actionList.get(i));
+            }
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public void onPopulateAccessibilityEvent(View view, AccessibilityEvent accessibilityEvent) {
+            this.mCompat.onPopulateAccessibilityEvent(view, accessibilityEvent);
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public boolean onRequestSendAccessibilityEvent(ViewGroup viewGroup, View view, AccessibilityEvent accessibilityEvent) {
+            return this.mCompat.onRequestSendAccessibilityEvent(viewGroup, view, accessibilityEvent);
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public void sendAccessibilityEvent(View view, int i) {
+            this.mCompat.sendAccessibilityEvent(view, i);
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public void sendAccessibilityEventUnchecked(View view, AccessibilityEvent accessibilityEvent) {
+            this.mCompat.sendAccessibilityEventUnchecked(view, accessibilityEvent);
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public AccessibilityNodeProvider getAccessibilityNodeProvider(View view) {
+            AccessibilityNodeProviderCompat accessibilityNodeProvider = this.mCompat.getAccessibilityNodeProvider(view);
+            if (accessibilityNodeProvider != null) {
+                return (AccessibilityNodeProvider) accessibilityNodeProvider.getProvider();
+            }
+            return null;
+        }
+
+        @Override // android.view.View.AccessibilityDelegate
+        public boolean performAccessibilityAction(View view, int i, Bundle bundle) {
+            return this.mCompat.performAccessibilityAction(view, i, bundle);
+        }
+    }
+
+    public AccessibilityDelegateCompat() {
+        this(DEFAULT_DELEGATE);
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public AccessibilityDelegateCompat(@NonNull View.AccessibilityDelegate accessibilityDelegate) {
+        this.mOriginalDelegate = accessibilityDelegate;
+        this.mBridge = new AccessibilityDelegateAdapter(this);
+    }
+
+    public void sendAccessibilityEvent(@NonNull View view, int i) {
+        this.mOriginalDelegate.sendAccessibilityEvent(view, i);
+    }
+
+    public void sendAccessibilityEventUnchecked(@NonNull View view, @NonNull AccessibilityEvent accessibilityEvent) {
+        this.mOriginalDelegate.sendAccessibilityEventUnchecked(view, accessibilityEvent);
+    }
+
+    public boolean dispatchPopulateAccessibilityEvent(@NonNull View view, @NonNull AccessibilityEvent accessibilityEvent) {
+        return this.mOriginalDelegate.dispatchPopulateAccessibilityEvent(view, accessibilityEvent);
+    }
+
+    public void onPopulateAccessibilityEvent(@NonNull View view, @NonNull AccessibilityEvent accessibilityEvent) {
+        this.mOriginalDelegate.onPopulateAccessibilityEvent(view, accessibilityEvent);
+    }
+
+    public void onInitializeAccessibilityEvent(@NonNull View view, @NonNull AccessibilityEvent accessibilityEvent) {
+        this.mOriginalDelegate.onInitializeAccessibilityEvent(view, accessibilityEvent);
+    }
+
+    public void onInitializeAccessibilityNodeInfo(@NonNull View view, @NonNull AccessibilityNodeInfoCompat accessibilityNodeInfoCompat) {
+        this.mOriginalDelegate.onInitializeAccessibilityNodeInfo(view, accessibilityNodeInfoCompat.unwrap());
+    }
+
+    public boolean onRequestSendAccessibilityEvent(@NonNull ViewGroup viewGroup, @NonNull View view, @NonNull AccessibilityEvent accessibilityEvent) {
+        return this.mOriginalDelegate.onRequestSendAccessibilityEvent(viewGroup, view, accessibilityEvent);
+    }
+
+    @Nullable
+    public AccessibilityNodeProviderCompat getAccessibilityNodeProvider(@NonNull View view) {
+        AccessibilityNodeProvider accessibilityNodeProvider = this.mOriginalDelegate.getAccessibilityNodeProvider(view);
+        if (accessibilityNodeProvider != null) {
+            return new AccessibilityNodeProviderCompat(accessibilityNodeProvider);
+        }
+        return null;
+    }
+
+    public boolean performAccessibilityAction(@NonNull View view, int i, @Nullable Bundle bundle) {
+        List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> actionList = getActionList(view);
+        boolean z = false;
+        int i2 = 0;
+        while (true) {
+            if (i2 >= actionList.size()) {
+                break;
+            }
+            AccessibilityNodeInfoCompat.AccessibilityActionCompat accessibilityActionCompat = actionList.get(i2);
+            if (accessibilityActionCompat.getId() == i) {
+                z = accessibilityActionCompat.perform(view, bundle);
+                break;
+            }
+            i2++;
+        }
+        if (!z) {
+            z = this.mOriginalDelegate.performAccessibilityAction(view, i, bundle);
+        }
+        return (z || i != R.id.accessibility_action_clickable_span || bundle == null) ? z : performClickableSpanAction(bundle.getInt(AccessibilityClickableSpanCompat.SPAN_ID, -1), view);
+    }
+
+    private boolean performClickableSpanAction(int i, View view) {
+        WeakReference weakReference;
+        SparseArray sparseArray = (SparseArray) view.getTag(R.id.tag_accessibility_clickable_spans);
+        if (sparseArray == null || (weakReference = (WeakReference) sparseArray.get(i)) == null) {
+            return false;
+        }
+        ClickableSpan clickableSpan = (ClickableSpan) weakReference.get();
+        if (!isSpanStillValid(clickableSpan, view)) {
+            return false;
+        }
+        clickableSpan.onClick(view);
+        return true;
+    }
+
+    private boolean isSpanStillValid(ClickableSpan clickableSpan, View view) {
+        if (clickableSpan != null) {
+            ClickableSpan[] clickableSpans = AccessibilityNodeInfoCompat.getClickableSpans(view.createAccessibilityNodeInfo().getText());
+            for (int i = 0; clickableSpans != null && i < clickableSpans.length; i++) {
+                if (clickableSpan.equals(clickableSpans[i])) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> getActionList(View view) {
+        List<AccessibilityNodeInfoCompat.AccessibilityActionCompat> list = (List) view.getTag(R.id.tag_accessibility_actions);
+        return list == null ? Collections.emptyList() : list;
+    }
+}

decompiled/sources/androidx/core/view/ActionProvider.java

@@ -0,0 +1,96 @@
+package androidx.core.view;
+
+import android.content.Context;
+import android.util.Log;
+import android.view.MenuItem;
+import android.view.SubMenu;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+
+/* loaded from: classes.dex */
+public abstract class ActionProvider {
+    private static final String TAG = "ActionProvider(support)";
+    private final Context mContext;
+    private SubUiVisibilityListener mSubUiVisibilityListener;
+    private VisibilityListener mVisibilityListener;
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public interface SubUiVisibilityListener {
+        void onSubUiVisibilityChanged(boolean z);
+    }
+
+    public interface VisibilityListener {
+        void onActionProviderVisibilityChanged(boolean z);
+    }
+
+    @NonNull
+    public Context getContext() {
+        return this.mContext;
+    }
+
+    public boolean hasSubMenu() {
+        return false;
+    }
+
+    public boolean isVisible() {
+        return true;
+    }
+
+    @NonNull
+    public abstract View onCreateActionView();
+
+    public boolean onPerformDefaultAction() {
+        return false;
+    }
+
+    public void onPrepareSubMenu(@NonNull SubMenu subMenu) {
+    }
+
+    public boolean overridesItemVisibility() {
+        return false;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public void reset() {
+        this.mVisibilityListener = null;
+        this.mSubUiVisibilityListener = null;
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public void setSubUiVisibilityListener(@Nullable SubUiVisibilityListener subUiVisibilityListener) {
+        this.mSubUiVisibilityListener = subUiVisibilityListener;
+    }
+
+    public ActionProvider(@NonNull Context context) {
+        this.mContext = context;
+    }
+
+    @NonNull
+    public View onCreateActionView(@NonNull MenuItem menuItem) {
+        return onCreateActionView();
+    }
+
+    public void refreshVisibility() {
+        if (this.mVisibilityListener == null || !overridesItemVisibility()) {
+            return;
+        }
+        this.mVisibilityListener.onActionProviderVisibilityChanged(isVisible());
+    }
+
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public void subUiVisibilityChanged(boolean z) {
+        SubUiVisibilityListener subUiVisibilityListener = this.mSubUiVisibilityListener;
+        if (subUiVisibilityListener != null) {
+            subUiVisibilityListener.onSubUiVisibilityChanged(z);
+        }
+    }
+
+    public void setVisibilityListener(@Nullable VisibilityListener visibilityListener) {
+        if (this.mVisibilityListener != null && visibilityListener != null) {
+            Log.w(TAG, "setVisibilityListener: Setting a new ActionProvider.VisibilityListener when one is already set. Are you reusing this " + getClass().getSimpleName() + " instance while it is still in use somewhere else?");
+        }
+        this.mVisibilityListener = visibilityListener;
+    }
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,10 @@
+package androidx.core.view;
+
+import android.view.ContentInfo;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ ContentInfo m(Object obj) {
+        return (ContentInfo) obj;
+    }
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline6.java

@@ -0,0 +1,11 @@
+package androidx.core.view;
+
+import android.content.ClipData;
+import android.view.ContentInfo;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline6 {
+    public static /* synthetic */ ContentInfo.Builder m(ClipData clipData, int i) {
+        return new ContentInfo.Builder(clipData, i);
+    }
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline7.java

@@ -0,0 +1,10 @@
+package androidx.core.view;
+
+import android.view.ContentInfo;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline7 {
+    public static /* synthetic */ ContentInfo.Builder m(ContentInfo contentInfo) {
+        return new ContentInfo.Builder(contentInfo);
+    }
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline8.java

@@ -0,0 +1,7 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline8 {
+    public static /* synthetic */ void m() {
+    }
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class ContentInfoCompat$Compat31Impl$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/core/view/ContentInfoCompat.java

@@ -0,0 +1,529 @@
+package androidx.core.view;
+
+import android.content.ClipData;
+import android.content.ClipDescription;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Pair;
+import android.view.ContentInfo;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.util.Preconditions;
+import androidx.core.util.Predicate;
+import com.facebook.share.internal.ShareConstants;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes.dex */
+public final class ContentInfoCompat {
+    public static final int FLAG_CONVERT_TO_PLAIN_TEXT = 1;
+    public static final int SOURCE_APP = 0;
+    public static final int SOURCE_AUTOFILL = 4;
+    public static final int SOURCE_CLIPBOARD = 1;
+    public static final int SOURCE_DRAG_AND_DROP = 3;
+    public static final int SOURCE_INPUT_METHOD = 2;
+    public static final int SOURCE_PROCESS_TEXT = 5;
+
+    @NonNull
+    private final Compat mCompat;
+
+    public interface BuilderCompat {
+        @NonNull
+        ContentInfoCompat build();
+
+        void setClip(@NonNull ClipData clipData);
+
+        void setExtras(@Nullable Bundle bundle);
+
+        void setFlags(int i);
+
+        void setLinkUri(@Nullable Uri uri);
+
+        void setSource(int i);
+    }
+
+    public interface Compat {
+        @NonNull
+        ClipData getClip();
+
+        @Nullable
+        Bundle getExtras();
+
+        int getFlags();
+
+        @Nullable
+        Uri getLinkUri();
+
+        int getSource();
+
+        @Nullable
+        ContentInfo getWrapped();
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface Flags {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface Source {
+    }
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static String sourceToString(int i) {
+        return i != 0 ? i != 1 ? i != 2 ? i != 3 ? i != 4 ? i != 5 ? String.valueOf(i) : "SOURCE_PROCESS_TEXT" : "SOURCE_AUTOFILL" : "SOURCE_DRAG_AND_DROP" : "SOURCE_INPUT_METHOD" : "SOURCE_CLIPBOARD" : "SOURCE_APP";
+    }
+
+    @NonNull
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static String flagsToString(int i) {
+        return (i & 1) != 0 ? "FLAG_CONVERT_TO_PLAIN_TEXT" : String.valueOf(i);
+    }
+
+    public ContentInfoCompat(@NonNull Compat compat) {
+        this.mCompat = compat;
+    }
+
+    @NonNull
+    @RequiresApi(31)
+    public static ContentInfoCompat toContentInfoCompat(@NonNull ContentInfo contentInfo) {
+        return new ContentInfoCompat(new Compat31Impl(contentInfo));
+    }
+
+    @NonNull
+    @RequiresApi(31)
+    public ContentInfo toContentInfo() {
+        ContentInfo wrapped = this.mCompat.getWrapped();
+        Objects.requireNonNull(wrapped);
+        return ContentInfoCompat$$ExternalSyntheticApiModelOutline0.m(wrapped);
+    }
+
+    @NonNull
+    public String toString() {
+        return this.mCompat.toString();
+    }
+
+    @NonNull
+    public ClipData getClip() {
+        return this.mCompat.getClip();
+    }
+
+    public int getSource() {
+        return this.mCompat.getSource();
+    }
+
+    public int getFlags() {
+        return this.mCompat.getFlags();
+    }
+
+    @Nullable
+    public Uri getLinkUri() {
+        return this.mCompat.getLinkUri();
+    }
+
+    @Nullable
+    public Bundle getExtras() {
+        return this.mCompat.getExtras();
+    }
+
+    @NonNull
+    public Pair<ContentInfoCompat, ContentInfoCompat> partition(@NonNull Predicate<ClipData.Item> predicate) {
+        ClipData clip = this.mCompat.getClip();
+        if (clip.getItemCount() == 1) {
+            boolean test = predicate.test(clip.getItemAt(0));
+            return Pair.create(test ? this : null, test ? null : this);
+        }
+        Pair<ClipData, ClipData> partition = partition(clip, predicate);
+        if (partition.first == null) {
+            return Pair.create(null, this);
+        }
+        if (partition.second == null) {
+            return Pair.create(this, null);
+        }
+        return Pair.create(new Builder(this).setClip((ClipData) partition.first).build(), new Builder(this).setClip((ClipData) partition.second).build());
+    }
+
+    @NonNull
+    public static Pair<ClipData, ClipData> partition(@NonNull ClipData clipData, @NonNull Predicate<ClipData.Item> predicate) {
+        ArrayList arrayList = null;
+        ArrayList arrayList2 = null;
+        for (int i = 0; i < clipData.getItemCount(); i++) {
+            ClipData.Item itemAt = clipData.getItemAt(i);
+            if (predicate.test(itemAt)) {
+                if (arrayList == null) {
+                    arrayList = new ArrayList();
+                }
+                arrayList.add(itemAt);
+            } else {
+                if (arrayList2 == null) {
+                    arrayList2 = new ArrayList();
+                }
+                arrayList2.add(itemAt);
+            }
+        }
+        if (arrayList == null) {
+            return Pair.create(null, clipData);
+        }
+        if (arrayList2 == null) {
+            return Pair.create(clipData, null);
+        }
+        return Pair.create(buildClipData(clipData.getDescription(), arrayList), buildClipData(clipData.getDescription(), arrayList2));
+    }
+
+    @NonNull
+    public static ClipData buildClipData(@NonNull ClipDescription clipDescription, @NonNull List<ClipData.Item> list) {
+        ClipData clipData = new ClipData(new ClipDescription(clipDescription), list.get(0));
+        for (int i = 1; i < list.size(); i++) {
+            clipData.addItem(list.get(i));
+        }
+        return clipData;
+    }
+
+    @NonNull
+    @RequiresApi(31)
+    public static Pair<ContentInfo, ContentInfo> partition(@NonNull ContentInfo contentInfo, @NonNull java.util.function.Predicate<ClipData.Item> predicate) {
+        return Api31Impl.partition(contentInfo, predicate);
+    }
+
+    @RequiresApi(31)
+    public static final class Api31Impl {
+        private Api31Impl() {
+        }
+
+        @NonNull
+        public static Pair<ContentInfo, ContentInfo> partition(@NonNull ContentInfo contentInfo, @NonNull final java.util.function.Predicate<ClipData.Item> predicate) {
+            ClipData clip = contentInfo.getClip();
+            if (clip.getItemCount() == 1) {
+                boolean test = predicate.test(clip.getItemAt(0));
+                ContentInfo contentInfo2 = test ? contentInfo : null;
+                if (test) {
+                    contentInfo = null;
+                }
+                return Pair.create(contentInfo2, contentInfo);
+            }
+            Objects.requireNonNull(predicate);
+            Pair<ClipData, ClipData> partition = ContentInfoCompat.partition(clip, (Predicate<ClipData.Item>) new Predicate() { // from class: androidx.core.view.ContentInfoCompat$Api31Impl$$ExternalSyntheticLambda0
+                @Override // androidx.core.util.Predicate
+                public final boolean test(Object obj) {
+                    return predicate.test((ClipData.Item) obj);
+                }
+            });
+            if (partition.first == null) {
+                return Pair.create(null, contentInfo);
+            }
+            if (partition.second == null) {
+                return Pair.create(contentInfo, null);
+            }
+            return Pair.create(new ContentInfo.Builder(contentInfo).setClip((ClipData) partition.first).build(), new ContentInfo.Builder(contentInfo).setClip((ClipData) partition.second).build());
+        }
+    }
+
+    public static final class CompatImpl implements Compat {
+
+        @NonNull
+        private final ClipData mClip;
+
+        @Nullable
+        private final Bundle mExtras;
+        private final int mFlags;
+
+        @Nullable
+        private final Uri mLinkUri;
+        private final int mSource;
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @NonNull
+        public ClipData getClip() {
+            return this.mClip;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @Nullable
+        public Bundle getExtras() {
+            return this.mExtras;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        public int getFlags() {
+            return this.mFlags;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @Nullable
+        public Uri getLinkUri() {
+            return this.mLinkUri;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        public int getSource() {
+            return this.mSource;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @Nullable
+        public ContentInfo getWrapped() {
+            return null;
+        }
+
+        public CompatImpl(BuilderCompatImpl builderCompatImpl) {
+            this.mClip = (ClipData) Preconditions.checkNotNull(builderCompatImpl.mClip);
+            this.mSource = Preconditions.checkArgumentInRange(builderCompatImpl.mSource, 0, 5, ShareConstants.FEED_SOURCE_PARAM);
+            this.mFlags = Preconditions.checkFlagsArgument(builderCompatImpl.mFlags, 1);
+            this.mLinkUri = builderCompatImpl.mLinkUri;
+            this.mExtras = builderCompatImpl.mExtras;
+        }
+
+        @NonNull
+        public String toString() {
+            String str;
+            StringBuilder sb = new StringBuilder();
+            sb.append("ContentInfoCompat{clip=");
+            sb.append(this.mClip.getDescription());
+            sb.append(", source=");
+            sb.append(ContentInfoCompat.sourceToString(this.mSource));
+            sb.append(", flags=");
+            sb.append(ContentInfoCompat.flagsToString(this.mFlags));
+            if (this.mLinkUri == null) {
+                str = "";
+            } else {
+                str = ", hasLinkUri(" + this.mLinkUri.toString().length() + ")";
+            }
+            sb.append(str);
+            sb.append(this.mExtras != null ? ", hasExtras" : "");
+            sb.append("}");
+            return sb.toString();
+        }
+    }
+
+    @RequiresApi(31)
+    public static final class Compat31Impl implements Compat {
+
+        @NonNull
+        private final ContentInfo mWrapped;
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @NonNull
+        public ContentInfo getWrapped() {
+            return this.mWrapped;
+        }
+
+        public Compat31Impl(@NonNull ContentInfo contentInfo) {
+            this.mWrapped = ContentInfoCompat$$ExternalSyntheticApiModelOutline0.m(Preconditions.checkNotNull(contentInfo));
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @NonNull
+        public ClipData getClip() {
+            ClipData clip;
+            clip = this.mWrapped.getClip();
+            return clip;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        public int getSource() {
+            int source;
+            source = this.mWrapped.getSource();
+            return source;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        public int getFlags() {
+            int flags;
+            flags = this.mWrapped.getFlags();
+            return flags;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @Nullable
+        public Uri getLinkUri() {
+            Uri linkUri;
+            linkUri = this.mWrapped.getLinkUri();
+            return linkUri;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.Compat
+        @Nullable
+        public Bundle getExtras() {
+            Bundle extras;
+            extras = this.mWrapped.getExtras();
+            return extras;
+        }
+
+        @NonNull
+        public String toString() {
+            return "ContentInfoCompat{" + this.mWrapped + "}";
+        }
+    }
+
+    public static final class Builder {
+
+        @NonNull
+        private final BuilderCompat mBuilderCompat;
+
+        public Builder(@NonNull ContentInfoCompat contentInfoCompat) {
+            if (Build.VERSION.SDK_INT >= 31) {
+                this.mBuilderCompat = new BuilderCompat31Impl(contentInfoCompat);
+            } else {
+                this.mBuilderCompat = new BuilderCompatImpl(contentInfoCompat);
+            }
+        }
+
+        public Builder(@NonNull ClipData clipData, int i) {
+            if (Build.VERSION.SDK_INT >= 31) {
+                this.mBuilderCompat = new BuilderCompat31Impl(clipData, i);
+            } else {
+                this.mBuilderCompat = new BuilderCompatImpl(clipData, i);
+            }
+        }
+
+        @NonNull
+        public Builder setClip(@NonNull ClipData clipData) {
+            this.mBuilderCompat.setClip(clipData);
+            return this;
+        }
+
+        @NonNull
+        public Builder setSource(int i) {
+            this.mBuilderCompat.setSource(i);
+            return this;
+        }
+
+        @NonNull
+        public Builder setFlags(int i) {
+            this.mBuilderCompat.setFlags(i);
+            return this;
+        }
+
+        @NonNull
+        public Builder setLinkUri(@Nullable Uri uri) {
+            this.mBuilderCompat.setLinkUri(uri);
+            return this;
+        }
+
+        @NonNull
+        public Builder setExtras(@Nullable Bundle bundle) {
+            this.mBuilderCompat.setExtras(bundle);
+            return this;
+        }
+
+        @NonNull
+        public ContentInfoCompat build() {
+            return this.mBuilderCompat.build();
+        }
+    }
+
+    public static final class BuilderCompatImpl implements BuilderCompat {
+
+        @NonNull
+        ClipData mClip;
+
+        @Nullable
+        Bundle mExtras;
+        int mFlags;
+
+        @Nullable
+        Uri mLinkUri;
+        int mSource;
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setClip(@NonNull ClipData clipData) {
+            this.mClip = clipData;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setExtras(@Nullable Bundle bundle) {
+            this.mExtras = bundle;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setFlags(int i) {
+            this.mFlags = i;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setLinkUri(@Nullable Uri uri) {
+            this.mLinkUri = uri;
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setSource(int i) {
+            this.mSource = i;
+        }
+
+        public BuilderCompatImpl(@NonNull ClipData clipData, int i) {
+            this.mClip = clipData;
+            this.mSource = i;
+        }
+
+        public BuilderCompatImpl(@NonNull ContentInfoCompat contentInfoCompat) {
+            this.mClip = contentInfoCompat.getClip();
+            this.mSource = contentInfoCompat.getSource();
+            this.mFlags = contentInfoCompat.getFlags();
+            this.mLinkUri = contentInfoCompat.getLinkUri();
+            this.mExtras = contentInfoCompat.getExtras();
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        @NonNull
+        public ContentInfoCompat build() {
+            return new ContentInfoCompat(new CompatImpl(this));
+        }
+    }
+
+    @RequiresApi(31)
+    public static final class BuilderCompat31Impl implements BuilderCompat {
+
+        @NonNull
+        private final ContentInfo.Builder mPlatformBuilder;
+
+        public BuilderCompat31Impl(@NonNull ClipData clipData, int i) {
+            this.mPlatformBuilder = ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline6.m(clipData, i);
+        }
+
+        public BuilderCompat31Impl(@NonNull ContentInfoCompat contentInfoCompat) {
+            ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline8.m();
+            this.mPlatformBuilder = ContentInfoCompat$BuilderCompat31Impl$$ExternalSyntheticApiModelOutline7.m(contentInfoCompat.toContentInfo());
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setClip(@NonNull ClipData clipData) {
+            this.mPlatformBuilder.setClip(clipData);
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setSource(int i) {
+            this.mPlatformBuilder.setSource(i);
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setFlags(int i) {
+            this.mPlatformBuilder.setFlags(i);
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setLinkUri(@Nullable Uri uri) {
+            this.mPlatformBuilder.setLinkUri(uri);
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        public void setExtras(@Nullable Bundle bundle) {
+            this.mPlatformBuilder.setExtras(bundle);
+        }
+
+        @Override // androidx.core.view.ContentInfoCompat.BuilderCompat
+        @NonNull
+        public ContentInfoCompat build() {
+            ContentInfo build;
+            build = this.mPlatformBuilder.build();
+            return new ContentInfoCompat(new Compat31Impl(build));
+        }
+    }
+}

decompiled/sources/androidx/core/view/DifferentialMotionFlingController.java

@@ -0,0 +1,122 @@
+package androidx.core.view;
+
+import android.content.Context;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+/* loaded from: classes.dex */
+public class DifferentialMotionFlingController {
+    private final Context mContext;
+    private final int[] mFlingVelocityThresholds;
+    private float mLastFlingVelocity;
+    private int mLastProcessedAxis;
+    private int mLastProcessedDeviceId;
+    private int mLastProcessedSource;
+    private final DifferentialMotionFlingTarget mTarget;
+    private final DifferentialVelocityProvider mVelocityProvider;
+    private final FlingVelocityThresholdCalculator mVelocityThresholdCalculator;
+
+    @Nullable
+    private VelocityTracker mVelocityTracker;
+
+    @VisibleForTesting
+    public interface DifferentialVelocityProvider {
+        float getCurrentVelocity(VelocityTracker velocityTracker, MotionEvent motionEvent, int i);
+    }
+
+    @VisibleForTesting
+    public interface FlingVelocityThresholdCalculator {
+        void calculateFlingVelocityThresholds(Context context, int[] iArr, MotionEvent motionEvent, int i);
+    }
+
+    public DifferentialMotionFlingController(@NonNull Context context, @NonNull DifferentialMotionFlingTarget differentialMotionFlingTarget) {
+        this(context, differentialMotionFlingTarget, new FlingVelocityThresholdCalculator() { // from class: androidx.core.view.DifferentialMotionFlingController$$ExternalSyntheticLambda0
+            @Override // androidx.core.view.DifferentialMotionFlingController.FlingVelocityThresholdCalculator
+            public final void calculateFlingVelocityThresholds(Context context2, int[] iArr, MotionEvent motionEvent, int i) {
+                DifferentialMotionFlingController.calculateFlingVelocityThresholds(context2, iArr, motionEvent, i);
+            }
+        }, new DifferentialVelocityProvider() { // from class: androidx.core.view.DifferentialMotionFlingController$$ExternalSyntheticLambda1
+            @Override // androidx.core.view.DifferentialMotionFlingController.DifferentialVelocityProvider
+            public final float getCurrentVelocity(VelocityTracker velocityTracker, MotionEvent motionEvent, int i) {
+                float currentVelocity;
+                currentVelocity = DifferentialMotionFlingController.getCurrentVelocity(velocityTracker, motionEvent, i);
+                return currentVelocity;
+            }
+        });
+    }
+
+    @VisibleForTesting
+    public DifferentialMotionFlingController(Context context, DifferentialMotionFlingTarget differentialMotionFlingTarget, FlingVelocityThresholdCalculator flingVelocityThresholdCalculator, DifferentialVelocityProvider differentialVelocityProvider) {
+        this.mLastProcessedAxis = -1;
+        this.mLastProcessedSource = -1;
+        this.mLastProcessedDeviceId = -1;
+        this.mFlingVelocityThresholds = new int[]{Integer.MAX_VALUE, 0};
+        this.mContext = context;
+        this.mTarget = differentialMotionFlingTarget;
+        this.mVelocityThresholdCalculator = flingVelocityThresholdCalculator;
+        this.mVelocityProvider = differentialVelocityProvider;
+    }
+
+    public void onMotionEvent(@NonNull MotionEvent motionEvent, int i) {
+        boolean calculateFlingVelocityThresholds = calculateFlingVelocityThresholds(motionEvent, i);
+        if (this.mFlingVelocityThresholds[0] == Integer.MAX_VALUE) {
+            VelocityTracker velocityTracker = this.mVelocityTracker;
+            if (velocityTracker != null) {
+                velocityTracker.recycle();
+                this.mVelocityTracker = null;
+                return;
+            }
+            return;
+        }
+        float currentVelocity = getCurrentVelocity(motionEvent, i) * this.mTarget.getScaledScrollFactor();
+        float signum = Math.signum(currentVelocity);
+        if (calculateFlingVelocityThresholds || (signum != Math.signum(this.mLastFlingVelocity) && signum != 0.0f)) {
+            this.mTarget.stopDifferentialMotionFling();
+        }
+        float abs = Math.abs(currentVelocity);
+        int[] iArr = this.mFlingVelocityThresholds;
+        if (abs < iArr[0]) {
+            return;
+        }
+        float max = Math.max(-r6, Math.min(currentVelocity, iArr[1]));
+        this.mLastFlingVelocity = this.mTarget.startDifferentialMotionFling(max) ? max : 0.0f;
+    }
+
+    private boolean calculateFlingVelocityThresholds(MotionEvent motionEvent, int i) {
+        int source = motionEvent.getSource();
+        int deviceId = motionEvent.getDeviceId();
+        if (this.mLastProcessedSource == source && this.mLastProcessedDeviceId == deviceId && this.mLastProcessedAxis == i) {
+            return false;
+        }
+        this.mVelocityThresholdCalculator.calculateFlingVelocityThresholds(this.mContext, this.mFlingVelocityThresholds, motionEvent, i);
+        this.mLastProcessedSource = source;
+        this.mLastProcessedDeviceId = deviceId;
+        this.mLastProcessedAxis = i;
+        return true;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void calculateFlingVelocityThresholds(Context context, int[] iArr, MotionEvent motionEvent, int i) {
+        ViewConfiguration viewConfiguration = ViewConfiguration.get(context);
+        iArr[0] = ViewConfigurationCompat.getScaledMinimumFlingVelocity(context, viewConfiguration, motionEvent.getDeviceId(), i, motionEvent.getSource());
+        iArr[1] = ViewConfigurationCompat.getScaledMaximumFlingVelocity(context, viewConfiguration, motionEvent.getDeviceId(), i, motionEvent.getSource());
+    }
+
+    private float getCurrentVelocity(MotionEvent motionEvent, int i) {
+        if (this.mVelocityTracker == null) {
+            this.mVelocityTracker = VelocityTracker.obtain();
+        }
+        return this.mVelocityProvider.getCurrentVelocity(this.mVelocityTracker, motionEvent, i);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static float getCurrentVelocity(VelocityTracker velocityTracker, MotionEvent motionEvent, int i) {
+        VelocityTrackerCompat.addMovement(velocityTracker, motionEvent);
+        VelocityTrackerCompat.computeCurrentVelocity(velocityTracker, 1000);
+        return VelocityTrackerCompat.getAxisVelocity(velocityTracker, i);
+    }
+}

decompiled/sources/androidx/core/view/DifferentialMotionFlingTarget.java

@@ -0,0 +1,10 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public interface DifferentialMotionFlingTarget {
+    float getScaledScrollFactor();
+
+    boolean startDifferentialMotionFling(float f);
+
+    void stopDifferentialMotionFling();
+}

decompiled/sources/androidx/core/view/DisplayCompat.java

@@ -0,0 +1,232 @@
+package androidx.core.view;
+
+import android.annotation.SuppressLint;
+import android.app.UiModeManager;
+import android.content.Context;
+import android.graphics.Point;
+import android.os.Build;
+import android.text.TextUtils;
+import android.view.Display;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Preconditions;
+
+/* loaded from: classes.dex */
+public final class DisplayCompat {
+    private static final int DISPLAY_SIZE_4K_HEIGHT = 2160;
+    private static final int DISPLAY_SIZE_4K_WIDTH = 3840;
+
+    private DisplayCompat() {
+    }
+
+    @NonNull
+    public static ModeCompat getMode(@NonNull Context context, @NonNull Display display) {
+        return Api23Impl.getMode(context, display);
+    }
+
+    @NonNull
+    private static Point getDisplaySize(@NonNull Context context, @NonNull Display display) {
+        Point currentDisplaySizeFromWorkarounds = getCurrentDisplaySizeFromWorkarounds(context, display);
+        if (currentDisplaySizeFromWorkarounds != null) {
+            return currentDisplaySizeFromWorkarounds;
+        }
+        Point point = new Point();
+        display.getRealSize(point);
+        return point;
+    }
+
+    @NonNull
+    @SuppressLint({"ArrayReturn"})
+    public static ModeCompat[] getSupportedModes(@NonNull Context context, @NonNull Display display) {
+        return Api23Impl.getSupportedModes(context, display);
+    }
+
+    private static Point parseDisplaySize(@NonNull String str) throws NumberFormatException {
+        String[] split = str.trim().split("x", -1);
+        if (split.length == 2) {
+            int parseInt = Integer.parseInt(split[0]);
+            int parseInt2 = Integer.parseInt(split[1]);
+            if (parseInt > 0 && parseInt2 > 0) {
+                return new Point(parseInt, parseInt2);
+            }
+        }
+        throw new NumberFormatException();
+    }
+
+    @Nullable
+    private static String getSystemProperty(String str) {
+        try {
+            Class<?> cls = Class.forName("android.os.SystemProperties");
+            return (String) cls.getMethod("get", String.class).invoke(cls, str);
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+
+    private static boolean isTv(@NonNull Context context) {
+        UiModeManager uiModeManager = (UiModeManager) context.getSystemService("uimode");
+        return uiModeManager != null && uiModeManager.getCurrentModeType() == 4;
+    }
+
+    @Nullable
+    private static Point parsePhysicalDisplaySizeFromSystemProperties(@NonNull String str, @NonNull Display display) {
+        if (display.getDisplayId() != 0) {
+            return null;
+        }
+        String systemProperty = getSystemProperty(str);
+        if (!TextUtils.isEmpty(systemProperty) && systemProperty != null) {
+            try {
+                return parseDisplaySize(systemProperty);
+            } catch (NumberFormatException unused) {
+            }
+        }
+        return null;
+    }
+
+    public static Point getCurrentDisplaySizeFromWorkarounds(@NonNull Context context, @NonNull Display display) {
+        Point parsePhysicalDisplaySizeFromSystemProperties;
+        if (Build.VERSION.SDK_INT < 28) {
+            parsePhysicalDisplaySizeFromSystemProperties = parsePhysicalDisplaySizeFromSystemProperties("sys.display-size", display);
+        } else {
+            parsePhysicalDisplaySizeFromSystemProperties = parsePhysicalDisplaySizeFromSystemProperties("vendor.display-size", display);
+        }
+        if (parsePhysicalDisplaySizeFromSystemProperties != null) {
+            return parsePhysicalDisplaySizeFromSystemProperties;
+        }
+        if (isSonyBravia4kTv(context) && isCurrentModeTheLargestMode(display)) {
+            return new Point(DISPLAY_SIZE_4K_WIDTH, DISPLAY_SIZE_4K_HEIGHT);
+        }
+        return null;
+    }
+
+    private static boolean isSonyBravia4kTv(@NonNull Context context) {
+        return isTv(context) && "Sony".equals(Build.MANUFACTURER) && Build.MODEL.startsWith("BRAVIA") && context.getPackageManager().hasSystemFeature("com.sony.dtv.hardware.panel.qfhd");
+    }
+
+    public static boolean isCurrentModeTheLargestMode(@NonNull Display display) {
+        return Api23Impl.isCurrentModeTheLargestMode(display);
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        @NonNull
+        public static ModeCompat getMode(@NonNull Context context, @NonNull Display display) {
+            Display.Mode mode = display.getMode();
+            Point currentDisplaySizeFromWorkarounds = DisplayCompat.getCurrentDisplaySizeFromWorkarounds(context, display);
+            if (currentDisplaySizeFromWorkarounds == null || physicalSizeEquals(mode, currentDisplaySizeFromWorkarounds)) {
+                return new ModeCompat(mode, true);
+            }
+            return new ModeCompat(mode, currentDisplaySizeFromWorkarounds);
+        }
+
+        @NonNull
+        @SuppressLint({"ArrayReturn"})
+        public static ModeCompat[] getSupportedModes(@NonNull Context context, @NonNull Display display) {
+            ModeCompat modeCompat;
+            Display.Mode[] supportedModes = display.getSupportedModes();
+            ModeCompat[] modeCompatArr = new ModeCompat[supportedModes.length];
+            Display.Mode mode = display.getMode();
+            Point currentDisplaySizeFromWorkarounds = DisplayCompat.getCurrentDisplaySizeFromWorkarounds(context, display);
+            if (currentDisplaySizeFromWorkarounds == null || physicalSizeEquals(mode, currentDisplaySizeFromWorkarounds)) {
+                for (int i = 0; i < supportedModes.length; i++) {
+                    modeCompatArr[i] = new ModeCompat(supportedModes[i], physicalSizeEquals(supportedModes[i], mode));
+                }
+            } else {
+                for (int i2 = 0; i2 < supportedModes.length; i2++) {
+                    if (physicalSizeEquals(supportedModes[i2], mode)) {
+                        modeCompat = new ModeCompat(supportedModes[i2], currentDisplaySizeFromWorkarounds);
+                    } else {
+                        modeCompat = new ModeCompat(supportedModes[i2], false);
+                    }
+                    modeCompatArr[i2] = modeCompat;
+                }
+            }
+            return modeCompatArr;
+        }
+
+        public static boolean isCurrentModeTheLargestMode(@NonNull Display display) {
+            Display.Mode mode = display.getMode();
+            for (Display.Mode mode2 : display.getSupportedModes()) {
+                if (mode.getPhysicalHeight() < mode2.getPhysicalHeight() || mode.getPhysicalWidth() < mode2.getPhysicalWidth()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public static boolean physicalSizeEquals(Display.Mode mode, Point point) {
+            return (mode.getPhysicalWidth() == point.x && mode.getPhysicalHeight() == point.y) || (mode.getPhysicalWidth() == point.y && mode.getPhysicalHeight() == point.x);
+        }
+
+        public static boolean physicalSizeEquals(Display.Mode mode, Display.Mode mode2) {
+            return mode.getPhysicalWidth() == mode2.getPhysicalWidth() && mode.getPhysicalHeight() == mode2.getPhysicalHeight();
+        }
+    }
+
+    public static final class ModeCompat {
+        private final boolean mIsNative;
+        private final Display.Mode mMode;
+        private final Point mPhysicalSize;
+
+        @Deprecated
+        public boolean isNative() {
+            return this.mIsNative;
+        }
+
+        @Nullable
+        @RequiresApi(23)
+        public Display.Mode toMode() {
+            return this.mMode;
+        }
+
+        public ModeCompat(@NonNull Point point) {
+            Preconditions.checkNotNull(point, "physicalSize == null");
+            this.mPhysicalSize = point;
+            this.mMode = null;
+            this.mIsNative = true;
+        }
+
+        @RequiresApi(23)
+        public ModeCompat(@NonNull Display.Mode mode, boolean z) {
+            Preconditions.checkNotNull(mode, "mode == null, can't wrap a null reference");
+            this.mPhysicalSize = new Point(Api23Impl.getPhysicalWidth(mode), Api23Impl.getPhysicalHeight(mode));
+            this.mMode = mode;
+            this.mIsNative = z;
+        }
+
+        @RequiresApi(23)
+        public ModeCompat(@NonNull Display.Mode mode, @NonNull Point point) {
+            Preconditions.checkNotNull(mode, "mode == null, can't wrap a null reference");
+            Preconditions.checkNotNull(point, "physicalSize == null");
+            this.mPhysicalSize = point;
+            this.mMode = mode;
+            this.mIsNative = true;
+        }
+
+        public int getPhysicalWidth() {
+            return this.mPhysicalSize.x;
+        }
+
+        public int getPhysicalHeight() {
+            return this.mPhysicalSize.y;
+        }
+
+        @RequiresApi(23)
+        public static class Api23Impl {
+            private Api23Impl() {
+            }
+
+            public static int getPhysicalWidth(Display.Mode mode) {
+                return mode.getPhysicalWidth();
+            }
+
+            public static int getPhysicalHeight(Display.Mode mode) {
+                return mode.getPhysicalHeight();
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/view/DisplayCutoutCompat$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class DisplayCutoutCompat$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/DisplayCutoutCompat.java

@@ -0,0 +1,230 @@
+package androidx.core.view;
+
+import android.graphics.Path;
+import android.graphics.Rect;
+import android.os.Build;
+import android.view.DisplayCutout;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.graphics.Insets;
+import androidx.core.util.ObjectsCompat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public final class DisplayCutoutCompat {
+    private final DisplayCutout mDisplayCutout;
+
+    @RequiresApi(28)
+    public DisplayCutout unwrap() {
+        return this.mDisplayCutout;
+    }
+
+    public DisplayCutoutCompat(@Nullable Rect rect, @Nullable List<Rect> list) {
+        this(Build.VERSION.SDK_INT >= 28 ? Api28Impl.createDisplayCutout(rect, list) : null);
+    }
+
+    public DisplayCutoutCompat(@NonNull Insets insets, @Nullable Rect rect, @Nullable Rect rect2, @Nullable Rect rect3, @Nullable Rect rect4, @NonNull Insets insets2) {
+        this(constructDisplayCutout(insets, rect, rect2, rect3, rect4, insets2, null));
+    }
+
+    public DisplayCutoutCompat(@NonNull Insets insets, @Nullable Rect rect, @Nullable Rect rect2, @Nullable Rect rect3, @Nullable Rect rect4, @NonNull Insets insets2, @Nullable Path path) {
+        this(constructDisplayCutout(insets, rect, rect2, rect3, rect4, insets2, path));
+    }
+
+    private static DisplayCutout constructDisplayCutout(@NonNull Insets insets, @Nullable Rect rect, @Nullable Rect rect2, @Nullable Rect rect3, @Nullable Rect rect4, @NonNull Insets insets2, @Nullable Path path) {
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 33) {
+            return Api33Impl.createDisplayCutout(insets.toPlatformInsets(), rect, rect2, rect3, rect4, insets2.toPlatformInsets(), path);
+        }
+        if (i >= 30) {
+            return Api30Impl.createDisplayCutout(insets.toPlatformInsets(), rect, rect2, rect3, rect4, insets2.toPlatformInsets());
+        }
+        if (i >= 29) {
+            return Api29Impl.createDisplayCutout(insets.toPlatformInsets(), rect, rect2, rect3, rect4);
+        }
+        if (i < 28) {
+            return null;
+        }
+        Rect rect5 = new Rect(insets.left, insets.top, insets.right, insets.bottom);
+        ArrayList arrayList = new ArrayList();
+        if (rect != null) {
+            arrayList.add(rect);
+        }
+        if (rect2 != null) {
+            arrayList.add(rect2);
+        }
+        if (rect3 != null) {
+            arrayList.add(rect3);
+        }
+        if (rect4 != null) {
+            arrayList.add(rect4);
+        }
+        return Api28Impl.createDisplayCutout(rect5, arrayList);
+    }
+
+    private DisplayCutoutCompat(DisplayCutout displayCutout) {
+        this.mDisplayCutout = displayCutout;
+    }
+
+    public int getSafeInsetTop() {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getSafeInsetTop(this.mDisplayCutout);
+        }
+        return 0;
+    }
+
+    public int getSafeInsetBottom() {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getSafeInsetBottom(this.mDisplayCutout);
+        }
+        return 0;
+    }
+
+    public int getSafeInsetLeft() {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getSafeInsetLeft(this.mDisplayCutout);
+        }
+        return 0;
+    }
+
+    public int getSafeInsetRight() {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getSafeInsetRight(this.mDisplayCutout);
+        }
+        return 0;
+    }
+
+    @NonNull
+    public List<Rect> getBoundingRects() {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getBoundingRects(this.mDisplayCutout);
+        }
+        return Collections.emptyList();
+    }
+
+    @NonNull
+    public Insets getWaterfallInsets() {
+        if (Build.VERSION.SDK_INT >= 30) {
+            return Insets.toCompatInsets(Api30Impl.getWaterfallInsets(this.mDisplayCutout));
+        }
+        return Insets.NONE;
+    }
+
+    @Nullable
+    public Path getCutoutPath() {
+        if (Build.VERSION.SDK_INT >= 31) {
+            return Api31Impl.getCutoutPath(this.mDisplayCutout);
+        }
+        return null;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || DisplayCutoutCompat.class != obj.getClass()) {
+            return false;
+        }
+        return ObjectsCompat.equals(this.mDisplayCutout, ((DisplayCutoutCompat) obj).mDisplayCutout);
+    }
+
+    public int hashCode() {
+        int hashCode;
+        DisplayCutout displayCutout = this.mDisplayCutout;
+        if (displayCutout == null) {
+            return 0;
+        }
+        hashCode = displayCutout.hashCode();
+        return hashCode;
+    }
+
+    @NonNull
+    public String toString() {
+        return "DisplayCutoutCompat{" + this.mDisplayCutout + "}";
+    }
+
+    public static DisplayCutoutCompat wrap(DisplayCutout displayCutout) {
+        if (displayCutout == null) {
+            return null;
+        }
+        return new DisplayCutoutCompat(displayCutout);
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static DisplayCutout createDisplayCutout(Rect rect, List<Rect> list) {
+            return new DisplayCutout(rect, list);
+        }
+
+        public static int getSafeInsetTop(DisplayCutout displayCutout) {
+            return displayCutout.getSafeInsetTop();
+        }
+
+        public static int getSafeInsetBottom(DisplayCutout displayCutout) {
+            return displayCutout.getSafeInsetBottom();
+        }
+
+        public static int getSafeInsetLeft(DisplayCutout displayCutout) {
+            return displayCutout.getSafeInsetLeft();
+        }
+
+        public static int getSafeInsetRight(DisplayCutout displayCutout) {
+            return displayCutout.getSafeInsetRight();
+        }
+
+        public static List<Rect> getBoundingRects(DisplayCutout displayCutout) {
+            return displayCutout.getBoundingRects();
+        }
+    }
+
+    @RequiresApi(29)
+    public static class Api29Impl {
+        private Api29Impl() {
+        }
+
+        public static DisplayCutout createDisplayCutout(android.graphics.Insets insets, Rect rect, Rect rect2, Rect rect3, Rect rect4) {
+            return new DisplayCutout(insets, rect, rect2, rect3, rect4);
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static DisplayCutout createDisplayCutout(android.graphics.Insets insets, Rect rect, Rect rect2, Rect rect3, Rect rect4, android.graphics.Insets insets2) {
+            return new DisplayCutout(insets, rect, rect2, rect3, rect4, insets2);
+        }
+
+        public static android.graphics.Insets getWaterfallInsets(DisplayCutout displayCutout) {
+            return displayCutout.getWaterfallInsets();
+        }
+    }
+
+    @RequiresApi(31)
+    public static class Api31Impl {
+        private Api31Impl() {
+        }
+
+        @Nullable
+        public static Path getCutoutPath(DisplayCutout displayCutout) {
+            return displayCutout.getCutoutPath();
+        }
+    }
+
+    @RequiresApi(33)
+    public static class Api33Impl {
+        private Api33Impl() {
+        }
+
+        public static DisplayCutout createDisplayCutout(android.graphics.Insets insets, Rect rect, Rect rect2, Rect rect3, Rect rect4, android.graphics.Insets insets2, Path path) {
+            return new DisplayCutout.Builder().setSafeInsets(insets).setBoundingRectLeft(rect).setBoundingRectTop(rect2).setBoundingRectRight(rect3).setBoundingRectBottom(rect4).setWaterfallInsets(insets2).setCutoutPath(path).build();
+        }
+    }
+}

decompiled/sources/androidx/core/view/DragAndDropPermissionsCompat.java

@@ -0,0 +1,46 @@
+package androidx.core.view;
+
+import android.app.Activity;
+import android.view.DragAndDropPermissions;
+import android.view.DragEvent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+
+/* loaded from: classes.dex */
+public final class DragAndDropPermissionsCompat {
+    private final DragAndDropPermissions mDragAndDropPermissions;
+
+    private DragAndDropPermissionsCompat(DragAndDropPermissions dragAndDropPermissions) {
+        this.mDragAndDropPermissions = dragAndDropPermissions;
+    }
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public static DragAndDropPermissionsCompat request(@NonNull Activity activity, @NonNull DragEvent dragEvent) {
+        DragAndDropPermissions requestDragAndDropPermissions = Api24Impl.requestDragAndDropPermissions(activity, dragEvent);
+        if (requestDragAndDropPermissions != null) {
+            return new DragAndDropPermissionsCompat(requestDragAndDropPermissions);
+        }
+        return null;
+    }
+
+    public void release() {
+        Api24Impl.release(this.mDragAndDropPermissions);
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static DragAndDropPermissions requestDragAndDropPermissions(Activity activity, DragEvent dragEvent) {
+            return activity.requestDragAndDropPermissions(dragEvent);
+        }
+
+        public static void release(DragAndDropPermissions dragAndDropPermissions) {
+            dragAndDropPermissions.release();
+        }
+    }
+}

decompiled/sources/androidx/core/view/DragStartHelper.java

@@ -0,0 +1,121 @@
+package androidx.core.view;
+
+import android.graphics.Point;
+import android.view.MotionEvent;
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public class DragStartHelper {
+    private boolean mDragging;
+    private int mLastTouchX;
+    private int mLastTouchY;
+    private final OnDragStartListener mListener;
+    private final View.OnLongClickListener mLongClickListener = new View.OnLongClickListener() { // from class: androidx.core.view.DragStartHelper$$ExternalSyntheticLambda0
+        @Override // android.view.View.OnLongClickListener
+        public final boolean onLongClick(View view) {
+            return DragStartHelper.this.onLongClick(view);
+        }
+    };
+    private final View.OnTouchListener mTouchListener = new View.OnTouchListener() { // from class: androidx.core.view.DragStartHelper$$ExternalSyntheticLambda1
+        @Override // android.view.View.OnTouchListener
+        public final boolean onTouch(View view, MotionEvent motionEvent) {
+            return DragStartHelper.this.onTouch(view, motionEvent);
+        }
+    };
+    private final View mView;
+
+    public interface OnDragStartListener {
+        boolean onDragStart(@NonNull View view, @NonNull DragStartHelper dragStartHelper);
+    }
+
+    public DragStartHelper(@NonNull View view, @NonNull OnDragStartListener onDragStartListener) {
+        this.mView = view;
+        this.mListener = onDragStartListener;
+    }
+
+    public void attach() {
+        this.mView.setOnLongClickListener(this.mLongClickListener);
+        this.mView.setOnTouchListener(this.mTouchListener);
+    }
+
+    public void detach() {
+        this.mView.setOnLongClickListener(null);
+        this.mView.setOnTouchListener(null);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:8:0x0018, code lost:
+    
+        if (r2 != 3) goto L28;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public boolean onTouch(@androidx.annotation.NonNull android.view.View r7, @androidx.annotation.NonNull android.view.MotionEvent r8) {
+        /*
+            r6 = this;
+            float r0 = r8.getX()
+            int r0 = (int) r0
+            float r1 = r8.getY()
+            int r1 = (int) r1
+            int r2 = r8.getAction()
+            r3 = 0
+            if (r2 == 0) goto L49
+            r4 = 1
+            if (r2 == r4) goto L46
+            r5 = 2
+            if (r2 == r5) goto L1b
+            r7 = 3
+            if (r2 == r7) goto L46
+            goto L4d
+        L1b:
+            r2 = 8194(0x2002, float:1.1482E-41)
+            boolean r2 = androidx.core.view.MotionEventCompat.isFromSource(r8, r2)
+            if (r2 == 0) goto L4d
+            int r8 = r8.getButtonState()
+            r8 = r8 & r4
+            if (r8 != 0) goto L2b
+            goto L4d
+        L2b:
+            boolean r8 = r6.mDragging
+            if (r8 == 0) goto L30
+            goto L4d
+        L30:
+            int r8 = r6.mLastTouchX
+            if (r8 != r0) goto L39
+            int r8 = r6.mLastTouchY
+            if (r8 != r1) goto L39
+            goto L4d
+        L39:
+            r6.mLastTouchX = r0
+            r6.mLastTouchY = r1
+            androidx.core.view.DragStartHelper$OnDragStartListener r8 = r6.mListener
+            boolean r7 = r8.onDragStart(r7, r6)
+            r6.mDragging = r7
+            return r7
+        L46:
+            r6.mDragging = r3
+            goto L4d
+        L49:
+            r6.mLastTouchX = r0
+            r6.mLastTouchY = r1
+        L4d:
+            return r3
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.view.DragStartHelper.onTouch(android.view.View, android.view.MotionEvent):boolean");
+    }
+
+    public boolean onLongClick(@NonNull View view) {
+        if (this.mDragging) {
+            return true;
+        }
+        boolean onDragStart = this.mListener.onDragStart(view, this);
+        this.mDragging = onDragStart;
+        return onDragStart;
+    }
+
+    public void getTouchPosition(@NonNull Point point) {
+        point.set(this.mLastTouchX, this.mLastTouchY);
+    }
+}

decompiled/sources/androidx/core/view/GestureDetectorCompat.java

@@ -0,0 +1,40 @@
+package androidx.core.view;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Handler;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+@Deprecated
+/* loaded from: classes.dex */
+public final class GestureDetectorCompat {
+    private final GestureDetector mDetector;
+
+    public GestureDetectorCompat(@NonNull Context context, @NonNull GestureDetector.OnGestureListener onGestureListener) {
+        this(context, onGestureListener, null);
+    }
+
+    public GestureDetectorCompat(@NonNull Context context, @NonNull GestureDetector.OnGestureListener onGestureListener, @Nullable Handler handler) {
+        this.mDetector = new GestureDetector(context, onGestureListener, handler);
+    }
+
+    public boolean isLongpressEnabled() {
+        return this.mDetector.isLongpressEnabled();
+    }
+
+    public boolean onTouchEvent(@NonNull MotionEvent motionEvent) {
+        return this.mDetector.onTouchEvent(motionEvent);
+    }
+
+    @SuppressLint({"KotlinPropertyAccess"})
+    public void setIsLongpressEnabled(boolean z) {
+        this.mDetector.setIsLongpressEnabled(z);
+    }
+
+    public void setOnDoubleTapListener(@Nullable GestureDetector.OnDoubleTapListener onDoubleTapListener) {
+        this.mDetector.setOnDoubleTapListener(onDoubleTapListener);
+    }
+}

decompiled/sources/androidx/core/view/GravityCompat.java

@@ -0,0 +1,32 @@
+package androidx.core.view;
+
+import android.graphics.Rect;
+import android.view.Gravity;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public final class GravityCompat {
+    public static final int END = 8388613;
+    public static final int RELATIVE_HORIZONTAL_GRAVITY_MASK = 8388615;
+    public static final int RELATIVE_LAYOUT_DIRECTION = 8388608;
+    public static final int START = 8388611;
+
+    public static void apply(int i, int i2, int i3, @NonNull Rect rect, @NonNull Rect rect2, int i4) {
+        Gravity.apply(i, i2, i3, rect, rect2, i4);
+    }
+
+    public static void apply(int i, int i2, int i3, @NonNull Rect rect, int i4, int i5, @NonNull Rect rect2, int i6) {
+        Gravity.apply(i, i2, i3, rect, i4, i5, rect2, i6);
+    }
+
+    public static void applyDisplay(int i, @NonNull Rect rect, @NonNull Rect rect2, int i2) {
+        Gravity.applyDisplay(i, rect, rect2, i2);
+    }
+
+    public static int getAbsoluteGravity(int i, int i2) {
+        return Gravity.getAbsoluteGravity(i, i2);
+    }
+
+    private GravityCompat() {
+    }
+}

decompiled/sources/androidx/core/view/HapticFeedbackConstantsCompat.java

@@ -0,0 +1,124 @@
+package androidx.core.view;
+
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes.dex */
+public final class HapticFeedbackConstantsCompat {
+    public static final int CLOCK_TICK = 4;
+    public static final int CONFIRM = 16;
+    public static final int CONTEXT_CLICK = 6;
+    public static final int DRAG_START = 25;
+
+    @VisibleForTesting
+    static final int FIRST_CONSTANT_INT = 0;
+    public static final int FLAG_IGNORE_VIEW_SETTING = 1;
+    public static final int GESTURE_END = 13;
+    public static final int GESTURE_START = 12;
+    public static final int GESTURE_THRESHOLD_ACTIVATE = 23;
+    public static final int GESTURE_THRESHOLD_DEACTIVATE = 24;
+    public static final int KEYBOARD_PRESS = 3;
+    public static final int KEYBOARD_RELEASE = 7;
+    public static final int KEYBOARD_TAP = 3;
+
+    @VisibleForTesting
+    static final int LAST_CONSTANT_INT = 27;
+    public static final int LONG_PRESS = 0;
+    public static final int NO_HAPTICS = -1;
+    public static final int REJECT = 17;
+    public static final int SEGMENT_FREQUENT_TICK = 27;
+    public static final int SEGMENT_TICK = 26;
+    public static final int TEXT_HANDLE_MOVE = 9;
+    public static final int TOGGLE_OFF = 22;
+    public static final int TOGGLE_ON = 21;
+    public static final int VIRTUAL_KEY = 1;
+    public static final int VIRTUAL_KEY_RELEASE = 8;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface HapticFeedbackFlags {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY})
+    public @interface HapticFeedbackType {
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:24:0x0033  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static int getFeedbackConstantOrFallback(int r5) {
+        /*
+            r0 = -1
+            if (r5 != r0) goto L4
+            return r0
+        L4:
+            int r1 = android.os.Build.VERSION.SDK_INT
+            r2 = 34
+            r3 = 6
+            r4 = 0
+            if (r1 >= r2) goto L15
+            switch(r5) {
+                case 21: goto L14;
+                case 22: goto L12;
+                case 23: goto L14;
+                case 24: goto L12;
+                case 25: goto L10;
+                case 26: goto L14;
+                case 27: goto L12;
+                default: goto Lf;
+            }
+        Lf:
+            goto L15
+        L10:
+            r5 = r4
+            goto L15
+        L12:
+            r5 = 4
+            goto L15
+        L14:
+            r5 = r3
+        L15:
+            r2 = 30
+            if (r1 >= r2) goto L2e
+            r2 = 12
+            if (r5 == r2) goto L2c
+            r2 = 13
+            if (r5 == r2) goto L2f
+            r2 = 16
+            if (r5 == r2) goto L2c
+            r2 = 17
+            if (r5 == r2) goto L2a
+            goto L2e
+        L2a:
+            r3 = r4
+            goto L2f
+        L2c:
+            r3 = 1
+            goto L2f
+        L2e:
+            r3 = r5
+        L2f:
+            r5 = 27
+            if (r1 >= r5) goto L3e
+            r5 = 7
+            if (r3 == r5) goto L3f
+            r5 = 8
+            if (r3 == r5) goto L3f
+            r5 = 9
+            if (r3 == r5) goto L3f
+        L3e:
+            r0 = r3
+        L3f:
+            return r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.core.view.HapticFeedbackConstantsCompat.getFeedbackConstantOrFallback(int):int");
+    }
+
+    private HapticFeedbackConstantsCompat() {
+    }
+}

decompiled/sources/androidx/core/view/InputDeviceCompat.java

@@ -0,0 +1,29 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public final class InputDeviceCompat {
+    public static final int SOURCE_ANY = -256;
+    public static final int SOURCE_CLASS_BUTTON = 1;
+    public static final int SOURCE_CLASS_JOYSTICK = 16;
+    public static final int SOURCE_CLASS_MASK = 255;
+    public static final int SOURCE_CLASS_NONE = 0;
+    public static final int SOURCE_CLASS_POINTER = 2;
+    public static final int SOURCE_CLASS_POSITION = 8;
+    public static final int SOURCE_CLASS_TRACKBALL = 4;
+    public static final int SOURCE_DPAD = 513;
+    public static final int SOURCE_GAMEPAD = 1025;
+    public static final int SOURCE_HDMI = 33554433;
+    public static final int SOURCE_JOYSTICK = 16777232;
+    public static final int SOURCE_KEYBOARD = 257;
+    public static final int SOURCE_MOUSE = 8194;
+    public static final int SOURCE_ROTARY_ENCODER = 4194304;
+    public static final int SOURCE_STYLUS = 16386;
+    public static final int SOURCE_TOUCHPAD = 1048584;
+    public static final int SOURCE_TOUCHSCREEN = 4098;
+    public static final int SOURCE_TOUCH_NAVIGATION = 2097152;
+    public static final int SOURCE_TRACKBALL = 65540;
+    public static final int SOURCE_UNKNOWN = 0;
+
+    private InputDeviceCompat() {
+    }
+}

decompiled/sources/androidx/core/view/KeyEventDispatcher.java

@@ -0,0 +1,132 @@
+package androidx.core.view;
+
+import android.annotation.SuppressLint;
+import android.app.ActionBar;
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Build;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.Window;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+/* loaded from: classes.dex */
+public class KeyEventDispatcher {
+    private static boolean sActionBarFieldsFetched = false;
+    private static Method sActionBarOnMenuKeyMethod = null;
+    private static boolean sDialogFieldsFetched = false;
+    private static Field sDialogKeyListenerField;
+
+    public interface Component {
+        boolean superDispatchKeyEvent(@NonNull KeyEvent keyEvent);
+    }
+
+    private KeyEventDispatcher() {
+    }
+
+    public static boolean dispatchBeforeHierarchy(@NonNull View view, @NonNull KeyEvent keyEvent) {
+        return ViewCompat.dispatchUnhandledKeyEventBeforeHierarchy(view, keyEvent);
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public static boolean dispatchKeyEvent(@NonNull Component component, @Nullable View view, @Nullable Window.Callback callback, @NonNull KeyEvent keyEvent) {
+        if (component == null) {
+            return false;
+        }
+        if (Build.VERSION.SDK_INT >= 28) {
+            return component.superDispatchKeyEvent(keyEvent);
+        }
+        if (callback instanceof Activity) {
+            return activitySuperDispatchKeyEventPre28((Activity) callback, keyEvent);
+        }
+        if (callback instanceof Dialog) {
+            return dialogSuperDispatchKeyEventPre28((Dialog) callback, keyEvent);
+        }
+        return (view != null && ViewCompat.dispatchUnhandledKeyEventBeforeCallback(view, keyEvent)) || component.superDispatchKeyEvent(keyEvent);
+    }
+
+    private static boolean actionBarOnMenuKeyEventPre28(ActionBar actionBar, KeyEvent keyEvent) {
+        if (!sActionBarFieldsFetched) {
+            try {
+                sActionBarOnMenuKeyMethod = actionBar.getClass().getMethod("onMenuKeyEvent", KeyEvent.class);
+            } catch (NoSuchMethodException unused) {
+            }
+            sActionBarFieldsFetched = true;
+        }
+        Method method = sActionBarOnMenuKeyMethod;
+        if (method != null) {
+            try {
+                Object invoke = method.invoke(actionBar, keyEvent);
+                if (invoke == null) {
+                    return false;
+                }
+                return ((Boolean) invoke).booleanValue();
+            } catch (IllegalAccessException | InvocationTargetException unused2) {
+            }
+        }
+        return false;
+    }
+
+    private static boolean activitySuperDispatchKeyEventPre28(Activity activity, KeyEvent keyEvent) {
+        activity.onUserInteraction();
+        Window window = activity.getWindow();
+        if (window.hasFeature(8)) {
+            ActionBar actionBar = activity.getActionBar();
+            if (keyEvent.getKeyCode() == 82 && actionBar != null && actionBarOnMenuKeyEventPre28(actionBar, keyEvent)) {
+                return true;
+            }
+        }
+        if (window.superDispatchKeyEvent(keyEvent)) {
+            return true;
+        }
+        View decorView = window.getDecorView();
+        if (ViewCompat.dispatchUnhandledKeyEventBeforeCallback(decorView, keyEvent)) {
+            return true;
+        }
+        return keyEvent.dispatch(activity, decorView != null ? decorView.getKeyDispatcherState() : null, activity);
+    }
+
+    private static DialogInterface.OnKeyListener getDialogKeyListenerPre28(Dialog dialog) {
+        if (!sDialogFieldsFetched) {
+            try {
+                Field declaredField = Dialog.class.getDeclaredField("mOnKeyListener");
+                sDialogKeyListenerField = declaredField;
+                declaredField.setAccessible(true);
+            } catch (NoSuchFieldException unused) {
+            }
+            sDialogFieldsFetched = true;
+        }
+        Field field = sDialogKeyListenerField;
+        if (field == null) {
+            return null;
+        }
+        try {
+            return (DialogInterface.OnKeyListener) field.get(dialog);
+        } catch (IllegalAccessException unused2) {
+            return null;
+        }
+    }
+
+    private static boolean dialogSuperDispatchKeyEventPre28(Dialog dialog, KeyEvent keyEvent) {
+        DialogInterface.OnKeyListener dialogKeyListenerPre28 = getDialogKeyListenerPre28(dialog);
+        if (dialogKeyListenerPre28 != null && dialogKeyListenerPre28.onKey(dialog, keyEvent.getKeyCode(), keyEvent)) {
+            return true;
+        }
+        Window window = dialog.getWindow();
+        if (window.superDispatchKeyEvent(keyEvent)) {
+            return true;
+        }
+        View decorView = window.getDecorView();
+        if (ViewCompat.dispatchUnhandledKeyEventBeforeCallback(decorView, keyEvent)) {
+            return true;
+        }
+        return keyEvent.dispatch(dialog, decorView != null ? decorView.getKeyDispatcherState() : null, dialog);
+    }
+}

decompiled/sources/androidx/core/view/LayoutInflaterCompat.java

@@ -0,0 +1,81 @@
+package androidx.core.view;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import androidx.annotation.NonNull;
+import java.lang.reflect.Field;
+
+/* loaded from: classes.dex */
+public final class LayoutInflaterCompat {
+    private static final String TAG = "LayoutInflaterCompatHC";
+    private static boolean sCheckedField;
+    private static Field sLayoutInflaterFactory2Field;
+
+    public static class Factory2Wrapper implements LayoutInflater.Factory2 {
+        final LayoutInflaterFactory mDelegateFactory;
+
+        public Factory2Wrapper(LayoutInflaterFactory layoutInflaterFactory) {
+            this.mDelegateFactory = layoutInflaterFactory;
+        }
+
+        @Override // android.view.LayoutInflater.Factory
+        public View onCreateView(String str, Context context, AttributeSet attributeSet) {
+            return this.mDelegateFactory.onCreateView(null, str, context, attributeSet);
+        }
+
+        @Override // android.view.LayoutInflater.Factory2
+        public View onCreateView(View view, String str, Context context, AttributeSet attributeSet) {
+            return this.mDelegateFactory.onCreateView(view, str, context, attributeSet);
+        }
+
+        @NonNull
+        public String toString() {
+            return getClass().getName() + "{" + this.mDelegateFactory + "}";
+        }
+    }
+
+    private static void forceSetFactory2(LayoutInflater layoutInflater, LayoutInflater.Factory2 factory2) {
+        if (!sCheckedField) {
+            try {
+                Field declaredField = LayoutInflater.class.getDeclaredField("mFactory2");
+                sLayoutInflaterFactory2Field = declaredField;
+                declaredField.setAccessible(true);
+            } catch (NoSuchFieldException e) {
+                Log.e(TAG, "forceSetFactory2 Could not find field 'mFactory2' on class " + LayoutInflater.class.getName() + "; inflation may have unexpected results.", e);
+            }
+            sCheckedField = true;
+        }
+        Field field = sLayoutInflaterFactory2Field;
+        if (field != null) {
+            try {
+                field.set(layoutInflater, factory2);
+            } catch (IllegalAccessException e2) {
+                Log.e(TAG, "forceSetFactory2 could not set the Factory2 on LayoutInflater " + layoutInflater + "; inflation may have unexpected results.", e2);
+            }
+        }
+    }
+
+    private LayoutInflaterCompat() {
+    }
+
+    @Deprecated
+    public static void setFactory(@NonNull LayoutInflater layoutInflater, @NonNull LayoutInflaterFactory layoutInflaterFactory) {
+        layoutInflater.setFactory2(new Factory2Wrapper(layoutInflaterFactory));
+    }
+
+    public static void setFactory2(@NonNull LayoutInflater layoutInflater, @NonNull LayoutInflater.Factory2 factory2) {
+        layoutInflater.setFactory2(factory2);
+    }
+
+    @Deprecated
+    public static LayoutInflaterFactory getFactory(LayoutInflater layoutInflater) {
+        LayoutInflater.Factory factory = layoutInflater.getFactory();
+        if (factory instanceof Factory2Wrapper) {
+            return ((Factory2Wrapper) factory).mDelegateFactory;
+        }
+        return null;
+    }
+}

decompiled/sources/androidx/core/view/LayoutInflaterFactory.java

@@ -0,0 +1,11 @@
+package androidx.core.view;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.View;
+
+@Deprecated
+/* loaded from: classes.dex */
+public interface LayoutInflaterFactory {
+    View onCreateView(View view, String str, Context context, AttributeSet attributeSet);
+}

decompiled/sources/androidx/core/view/MarginLayoutParamsCompat.java

@@ -0,0 +1,63 @@
+package androidx.core.view;
+
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+
+@Deprecated
+/* loaded from: classes.dex */
+public final class MarginLayoutParamsCompat {
+    @ReplaceWith(expression = "lp.getMarginStart()")
+    @Deprecated
+    public static int getMarginStart(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams) {
+        return marginLayoutParams.getMarginStart();
+    }
+
+    @ReplaceWith(expression = "lp.getMarginEnd()")
+    @Deprecated
+    public static int getMarginEnd(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams) {
+        return marginLayoutParams.getMarginEnd();
+    }
+
+    @ReplaceWith(expression = "lp.setMarginStart(marginStart)")
+    @Deprecated
+    public static void setMarginStart(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams, int i) {
+        marginLayoutParams.setMarginStart(i);
+    }
+
+    @ReplaceWith(expression = "lp.setMarginEnd(marginEnd)")
+    @Deprecated
+    public static void setMarginEnd(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams, int i) {
+        marginLayoutParams.setMarginEnd(i);
+    }
+
+    @ReplaceWith(expression = "lp.isMarginRelative()")
+    @Deprecated
+    public static boolean isMarginRelative(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams) {
+        return marginLayoutParams.isMarginRelative();
+    }
+
+    @Deprecated
+    public static int getLayoutDirection(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams) {
+        int layoutDirection = marginLayoutParams.getLayoutDirection();
+        if (layoutDirection == 0 || layoutDirection == 1) {
+            return layoutDirection;
+        }
+        return 0;
+    }
+
+    @ReplaceWith(expression = "lp.setLayoutDirection(layoutDirection)")
+    @Deprecated
+    public static void setLayoutDirection(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams, int i) {
+        marginLayoutParams.setLayoutDirection(i);
+    }
+
+    @ReplaceWith(expression = "lp.resolveLayoutDirection(layoutDirection)")
+    @Deprecated
+    public static void resolveLayoutDirection(@NonNull ViewGroup.MarginLayoutParams marginLayoutParams, int i) {
+        marginLayoutParams.resolveLayoutDirection(i);
+    }
+
+    private MarginLayoutParamsCompat() {
+    }
+}

decompiled/sources/androidx/core/view/MenuCompat.java

@@ -0,0 +1,39 @@
+package androidx.core.view;
+
+import android.os.Build;
+import android.view.Menu;
+import android.view.MenuItem;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+import androidx.core.internal.view.SupportMenu;
+
+/* loaded from: classes.dex */
+public final class MenuCompat {
+    @ReplaceWith(expression = "item.setShowAsAction(actionEnum)")
+    @Deprecated
+    public static void setShowAsAction(MenuItem menuItem, int i) {
+        menuItem.setShowAsAction(i);
+    }
+
+    public static void setGroupDividerEnabled(@NonNull Menu menu, boolean z) {
+        if (menu instanceof SupportMenu) {
+            ((SupportMenu) menu).setGroupDividerEnabled(z);
+        } else if (Build.VERSION.SDK_INT >= 28) {
+            Api28Impl.setGroupDividerEnabled(menu, z);
+        }
+    }
+
+    private MenuCompat() {
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static void setGroupDividerEnabled(Menu menu, boolean z) {
+            menu.setGroupDividerEnabled(z);
+        }
+    }
+}

decompiled/sources/androidx/core/view/MenuHost.java

@@ -0,0 +1,20 @@
+package androidx.core.view;
+
+import android.annotation.SuppressLint;
+import androidx.annotation.NonNull;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
+
+/* loaded from: classes.dex */
+public interface MenuHost {
+    void addMenuProvider(@NonNull MenuProvider menuProvider);
+
+    void addMenuProvider(@NonNull MenuProvider menuProvider, @NonNull LifecycleOwner lifecycleOwner);
+
+    @SuppressLint({"LambdaLast"})
+    void addMenuProvider(@NonNull MenuProvider menuProvider, @NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.State state);
+
+    void invalidateMenu();
+
+    void removeMenuProvider(@NonNull MenuProvider menuProvider);
+}

decompiled/sources/androidx/core/view/MenuHostHelper.java

@@ -0,0 +1,137 @@
+package androidx.core.view;
+
+import android.annotation.SuppressLint;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import androidx.annotation.NonNull;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleOwner;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes.dex */
+public class MenuHostHelper {
+    private final Runnable mOnInvalidateMenuCallback;
+    private final CopyOnWriteArrayList<MenuProvider> mMenuProviders = new CopyOnWriteArrayList<>();
+    private final Map<MenuProvider, LifecycleContainer> mProviderToLifecycleContainers = new HashMap();
+
+    public MenuHostHelper(@NonNull Runnable runnable) {
+        this.mOnInvalidateMenuCallback = runnable;
+    }
+
+    public void onPrepareMenu(@NonNull Menu menu) {
+        Iterator<MenuProvider> it = this.mMenuProviders.iterator();
+        while (it.hasNext()) {
+            it.next().onPrepareMenu(menu);
+        }
+    }
+
+    public void onCreateMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater) {
+        Iterator<MenuProvider> it = this.mMenuProviders.iterator();
+        while (it.hasNext()) {
+            it.next().onCreateMenu(menu, menuInflater);
+        }
+    }
+
+    public boolean onMenuItemSelected(@NonNull MenuItem menuItem) {
+        Iterator<MenuProvider> it = this.mMenuProviders.iterator();
+        while (it.hasNext()) {
+            if (it.next().onMenuItemSelected(menuItem)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void onMenuClosed(@NonNull Menu menu) {
+        Iterator<MenuProvider> it = this.mMenuProviders.iterator();
+        while (it.hasNext()) {
+            it.next().onMenuClosed(menu);
+        }
+    }
+
+    public void addMenuProvider(@NonNull MenuProvider menuProvider) {
+        this.mMenuProviders.add(menuProvider);
+        this.mOnInvalidateMenuCallback.run();
+    }
+
+    public void addMenuProvider(@NonNull final MenuProvider menuProvider, @NonNull LifecycleOwner lifecycleOwner) {
+        addMenuProvider(menuProvider);
+        Lifecycle lifecycle = lifecycleOwner.getLifecycle();
+        LifecycleContainer remove = this.mProviderToLifecycleContainers.remove(menuProvider);
+        if (remove != null) {
+            remove.clearObservers();
+        }
+        this.mProviderToLifecycleContainers.put(menuProvider, new LifecycleContainer(lifecycle, new LifecycleEventObserver() { // from class: androidx.core.view.MenuHostHelper$$ExternalSyntheticLambda0
+            @Override // androidx.lifecycle.LifecycleEventObserver
+            public final void onStateChanged(LifecycleOwner lifecycleOwner2, Lifecycle.Event event) {
+                MenuHostHelper.this.lambda$addMenuProvider$0(menuProvider, lifecycleOwner2, event);
+            }
+        }));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$addMenuProvider$0(MenuProvider menuProvider, LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
+        if (event == Lifecycle.Event.ON_DESTROY) {
+            removeMenuProvider(menuProvider);
+        }
+    }
+
+    @SuppressLint({"LambdaLast"})
+    public void addMenuProvider(@NonNull final MenuProvider menuProvider, @NonNull LifecycleOwner lifecycleOwner, @NonNull final Lifecycle.State state) {
+        Lifecycle lifecycle = lifecycleOwner.getLifecycle();
+        LifecycleContainer remove = this.mProviderToLifecycleContainers.remove(menuProvider);
+        if (remove != null) {
+            remove.clearObservers();
+        }
+        this.mProviderToLifecycleContainers.put(menuProvider, new LifecycleContainer(lifecycle, new LifecycleEventObserver() { // from class: androidx.core.view.MenuHostHelper$$ExternalSyntheticLambda1
+            @Override // androidx.lifecycle.LifecycleEventObserver
+            public final void onStateChanged(LifecycleOwner lifecycleOwner2, Lifecycle.Event event) {
+                MenuHostHelper.this.lambda$addMenuProvider$1(state, menuProvider, lifecycleOwner2, event);
+            }
+        }));
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public /* synthetic */ void lambda$addMenuProvider$1(Lifecycle.State state, MenuProvider menuProvider, LifecycleOwner lifecycleOwner, Lifecycle.Event event) {
+        if (event == Lifecycle.Event.upTo(state)) {
+            addMenuProvider(menuProvider);
+            return;
+        }
+        if (event == Lifecycle.Event.ON_DESTROY) {
+            removeMenuProvider(menuProvider);
+        } else if (event == Lifecycle.Event.downFrom(state)) {
+            this.mMenuProviders.remove(menuProvider);
+            this.mOnInvalidateMenuCallback.run();
+        }
+    }
+
+    public void removeMenuProvider(@NonNull MenuProvider menuProvider) {
+        this.mMenuProviders.remove(menuProvider);
+        LifecycleContainer remove = this.mProviderToLifecycleContainers.remove(menuProvider);
+        if (remove != null) {
+            remove.clearObservers();
+        }
+        this.mOnInvalidateMenuCallback.run();
+    }
+
+    public static class LifecycleContainer {
+        final Lifecycle mLifecycle;
+        private LifecycleEventObserver mObserver;
+
+        public LifecycleContainer(@NonNull Lifecycle lifecycle, @NonNull LifecycleEventObserver lifecycleEventObserver) {
+            this.mLifecycle = lifecycle;
+            this.mObserver = lifecycleEventObserver;
+            lifecycle.addObserver(lifecycleEventObserver);
+        }
+
+        public void clearObservers() {
+            this.mLifecycle.removeObserver(this.mObserver);
+            this.mObserver = null;
+        }
+    }
+}

decompiled/sources/androidx/core/view/MenuItemCompat.java

@@ -0,0 +1,277 @@
+package androidx.core.view;
+
+import android.content.res.ColorStateList;
+import android.graphics.PorterDuff;
+import android.util.Log;
+import android.view.MenuItem;
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+import androidx.core.internal.view.SupportMenuItem;
+
+/* loaded from: classes.dex */
+public final class MenuItemCompat {
+
+    @Deprecated
+    public static final int SHOW_AS_ACTION_ALWAYS = 2;
+
+    @Deprecated
+    public static final int SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW = 8;
+
+    @Deprecated
+    public static final int SHOW_AS_ACTION_IF_ROOM = 1;
+
+    @Deprecated
+    public static final int SHOW_AS_ACTION_NEVER = 0;
+
+    @Deprecated
+    public static final int SHOW_AS_ACTION_WITH_TEXT = 4;
+    private static final String TAG = "MenuItemCompat";
+
+    @Deprecated
+    public interface OnActionExpandListener {
+        boolean onMenuItemActionCollapse(MenuItem menuItem);
+
+        boolean onMenuItemActionExpand(MenuItem menuItem);
+    }
+
+    @ReplaceWith(expression = "item.setShowAsAction(actionEnum)")
+    @Deprecated
+    public static void setShowAsAction(MenuItem menuItem, int i) {
+        menuItem.setShowAsAction(i);
+    }
+
+    @ReplaceWith(expression = "item.setActionView(view)")
+    @Deprecated
+    public static MenuItem setActionView(MenuItem menuItem, View view) {
+        return menuItem.setActionView(view);
+    }
+
+    @ReplaceWith(expression = "item.setActionView(resId)")
+    @Deprecated
+    public static MenuItem setActionView(MenuItem menuItem, int i) {
+        return menuItem.setActionView(i);
+    }
+
+    @ReplaceWith(expression = "item.getActionView()")
+    @Deprecated
+    public static View getActionView(MenuItem menuItem) {
+        return menuItem.getActionView();
+    }
+
+    @Nullable
+    public static MenuItem setActionProvider(@NonNull MenuItem menuItem, @Nullable ActionProvider actionProvider) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).setSupportActionProvider(actionProvider);
+        }
+        Log.w(TAG, "setActionProvider: item does not implement SupportMenuItem; ignoring");
+        return menuItem;
+    }
+
+    @Nullable
+    public static ActionProvider getActionProvider(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getSupportActionProvider();
+        }
+        Log.w(TAG, "getActionProvider: item does not implement SupportMenuItem; returning null");
+        return null;
+    }
+
+    @ReplaceWith(expression = "item.expandActionView()")
+    @Deprecated
+    public static boolean expandActionView(MenuItem menuItem) {
+        return menuItem.expandActionView();
+    }
+
+    @ReplaceWith(expression = "item.collapseActionView()")
+    @Deprecated
+    public static boolean collapseActionView(MenuItem menuItem) {
+        return menuItem.collapseActionView();
+    }
+
+    @ReplaceWith(expression = "item.isActionViewExpanded()")
+    @Deprecated
+    public static boolean isActionViewExpanded(MenuItem menuItem) {
+        return menuItem.isActionViewExpanded();
+    }
+
+    @Deprecated
+    public static MenuItem setOnActionExpandListener(MenuItem menuItem, final OnActionExpandListener onActionExpandListener) {
+        return menuItem.setOnActionExpandListener(new MenuItem.OnActionExpandListener() { // from class: androidx.core.view.MenuItemCompat.1
+            @Override // android.view.MenuItem.OnActionExpandListener
+            public boolean onMenuItemActionExpand(MenuItem menuItem2) {
+                return OnActionExpandListener.this.onMenuItemActionExpand(menuItem2);
+            }
+
+            @Override // android.view.MenuItem.OnActionExpandListener
+            public boolean onMenuItemActionCollapse(MenuItem menuItem2) {
+                return OnActionExpandListener.this.onMenuItemActionCollapse(menuItem2);
+            }
+        });
+    }
+
+    public static void setContentDescription(@NonNull MenuItem menuItem, @Nullable CharSequence charSequence) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setContentDescription(charSequence);
+        } else {
+            Api26Impl.setContentDescription(menuItem, charSequence);
+        }
+    }
+
+    @Nullable
+    public static CharSequence getContentDescription(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getContentDescription();
+        }
+        return Api26Impl.getContentDescription(menuItem);
+    }
+
+    public static void setTooltipText(@NonNull MenuItem menuItem, @Nullable CharSequence charSequence) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setTooltipText(charSequence);
+        } else {
+            Api26Impl.setTooltipText(menuItem, charSequence);
+        }
+    }
+
+    @Nullable
+    public static CharSequence getTooltipText(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getTooltipText();
+        }
+        return Api26Impl.getTooltipText(menuItem);
+    }
+
+    public static void setShortcut(@NonNull MenuItem menuItem, char c, char c2, int i, int i2) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setShortcut(c, c2, i, i2);
+        } else {
+            Api26Impl.setShortcut(menuItem, c, c2, i, i2);
+        }
+    }
+
+    public static void setNumericShortcut(@NonNull MenuItem menuItem, char c, int i) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setNumericShortcut(c, i);
+        } else {
+            Api26Impl.setNumericShortcut(menuItem, c, i);
+        }
+    }
+
+    public static int getNumericModifiers(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getNumericModifiers();
+        }
+        return Api26Impl.getNumericModifiers(menuItem);
+    }
+
+    public static void setAlphabeticShortcut(@NonNull MenuItem menuItem, char c, int i) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setAlphabeticShortcut(c, i);
+        } else {
+            Api26Impl.setAlphabeticShortcut(menuItem, c, i);
+        }
+    }
+
+    public static int getAlphabeticModifiers(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getAlphabeticModifiers();
+        }
+        return Api26Impl.getAlphabeticModifiers(menuItem);
+    }
+
+    public static void setIconTintList(@NonNull MenuItem menuItem, @Nullable ColorStateList colorStateList) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setIconTintList(colorStateList);
+        } else {
+            Api26Impl.setIconTintList(menuItem, colorStateList);
+        }
+    }
+
+    @Nullable
+    public static ColorStateList getIconTintList(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getIconTintList();
+        }
+        return Api26Impl.getIconTintList(menuItem);
+    }
+
+    public static void setIconTintMode(@NonNull MenuItem menuItem, @Nullable PorterDuff.Mode mode) {
+        if (menuItem instanceof SupportMenuItem) {
+            ((SupportMenuItem) menuItem).setIconTintMode(mode);
+        } else {
+            Api26Impl.setIconTintMode(menuItem, mode);
+        }
+    }
+
+    @Nullable
+    public static PorterDuff.Mode getIconTintMode(@NonNull MenuItem menuItem) {
+        if (menuItem instanceof SupportMenuItem) {
+            return ((SupportMenuItem) menuItem).getIconTintMode();
+        }
+        return Api26Impl.getIconTintMode(menuItem);
+    }
+
+    private MenuItemCompat() {
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static MenuItem setContentDescription(MenuItem menuItem, CharSequence charSequence) {
+            return menuItem.setContentDescription(charSequence);
+        }
+
+        public static CharSequence getContentDescription(MenuItem menuItem) {
+            return menuItem.getContentDescription();
+        }
+
+        public static MenuItem setTooltipText(MenuItem menuItem, CharSequence charSequence) {
+            return menuItem.setTooltipText(charSequence);
+        }
+
+        public static CharSequence getTooltipText(MenuItem menuItem) {
+            return menuItem.getTooltipText();
+        }
+
+        public static MenuItem setShortcut(MenuItem menuItem, char c, char c2, int i, int i2) {
+            return menuItem.setShortcut(c, c2, i, i2);
+        }
+
+        public static MenuItem setNumericShortcut(MenuItem menuItem, char c, int i) {
+            return menuItem.setNumericShortcut(c, i);
+        }
+
+        public static int getNumericModifiers(MenuItem menuItem) {
+            return menuItem.getNumericModifiers();
+        }
+
+        public static MenuItem setAlphabeticShortcut(MenuItem menuItem, char c, int i) {
+            return menuItem.setAlphabeticShortcut(c, i);
+        }
+
+        public static int getAlphabeticModifiers(MenuItem menuItem) {
+            return menuItem.getAlphabeticModifiers();
+        }
+
+        public static MenuItem setIconTintList(MenuItem menuItem, ColorStateList colorStateList) {
+            return menuItem.setIconTintList(colorStateList);
+        }
+
+        public static ColorStateList getIconTintList(MenuItem menuItem) {
+            return menuItem.getIconTintList();
+        }
+
+        public static MenuItem setIconTintMode(MenuItem menuItem, PorterDuff.Mode mode) {
+            return menuItem.setIconTintMode(mode);
+        }
+
+        public static PorterDuff.Mode getIconTintMode(MenuItem menuItem) {
+            return menuItem.getIconTintMode();
+        }
+    }
+}

decompiled/sources/androidx/core/view/MenuKt$iterator$1.java

@@ -0,0 +1,55 @@
+package androidx.core.view;
+
+import android.view.Menu;
+import android.view.MenuItem;
+import java.util.Iterator;
+import kotlin.Unit;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.jvm.internal.markers.KMutableIterator;
+
+@SourceDebugExtension({"SMAP\nMenu.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Menu.kt\nandroidx/core/view/MenuKt$iterator$1\n+ 2 Menu.kt\nandroidx/core/view/MenuKt\n+ 3 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,95:1\n87#2:96\n1#3:97\n*S KotlinDebug\n*F\n+ 1 Menu.kt\nandroidx/core/view/MenuKt$iterator$1\n*L\n78#1:96\n78#1:97\n*E\n"})
+/* loaded from: classes.dex */
+public final class MenuKt$iterator$1 implements Iterator<MenuItem>, KMutableIterator {
+    final /* synthetic */ Menu $this_iterator;
+    private int index;
+
+    public MenuKt$iterator$1(Menu menu) {
+        this.$this_iterator = menu;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.$this_iterator.size();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // java.util.Iterator
+    public MenuItem next() {
+        Menu menu = this.$this_iterator;
+        int i = this.index;
+        this.index = i + 1;
+        MenuItem item = menu.getItem(i);
+        if (item != null) {
+            return item;
+        }
+        throw new IndexOutOfBoundsException();
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        Unit unit;
+        Menu menu = this.$this_iterator;
+        int i = this.index - 1;
+        this.index = i;
+        MenuItem item = menu.getItem(i);
+        if (item != null) {
+            menu.removeItem(item.getItemId());
+            unit = Unit.INSTANCE;
+        } else {
+            unit = null;
+        }
+        if (unit == null) {
+            throw new IndexOutOfBoundsException();
+        }
+    }
+}

decompiled/sources/androidx/core/view/MenuKt.java

@@ -0,0 +1,86 @@
+package androidx.core.view;
+
+import android.view.Menu;
+import android.view.MenuItem;
+import java.util.Iterator;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.sequences.Sequence;
+
+@SourceDebugExtension({"SMAP\nMenu.kt\nKotlin\n*S Kotlin\n*F\n+ 1 Menu.kt\nandroidx/core/view/MenuKt\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,95:1\n1#2:96\n*E\n"})
+/* loaded from: classes.dex */
+public final class MenuKt {
+    public static final MenuItem get(Menu menu, int i) {
+        return menu.getItem(i);
+    }
+
+    public static final boolean contains(Menu menu, MenuItem menuItem) {
+        int size = menu.size();
+        for (int i = 0; i < size; i++) {
+            if (Intrinsics.areEqual(menu.getItem(i), menuItem)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static final void minusAssign(Menu menu, MenuItem menuItem) {
+        menu.removeItem(menuItem.getItemId());
+    }
+
+    public static final int getSize(Menu menu) {
+        return menu.size();
+    }
+
+    public static final boolean isEmpty(Menu menu) {
+        return menu.size() == 0;
+    }
+
+    public static final boolean isNotEmpty(Menu menu) {
+        return menu.size() != 0;
+    }
+
+    public static final void forEach(Menu menu, Function1 function1) {
+        int size = menu.size();
+        for (int i = 0; i < size; i++) {
+            function1.invoke(menu.getItem(i));
+        }
+    }
+
+    public static final void forEachIndexed(Menu menu, Function2 function2) {
+        int size = menu.size();
+        for (int i = 0; i < size; i++) {
+            function2.invoke(Integer.valueOf(i), menu.getItem(i));
+        }
+    }
+
+    public static final Iterator<MenuItem> iterator(Menu menu) {
+        return new MenuKt$iterator$1(menu);
+    }
+
+    public static final void removeItemAt(Menu menu, int i) {
+        Unit unit;
+        MenuItem item = menu.getItem(i);
+        if (item != null) {
+            menu.removeItem(item.getItemId());
+            unit = Unit.INSTANCE;
+        } else {
+            unit = null;
+        }
+        if (unit == null) {
+            throw new IndexOutOfBoundsException();
+        }
+    }
+
+    public static final Sequence getChildren(final Menu menu) {
+        return new Sequence() { // from class: androidx.core.view.MenuKt$children$1
+            @Override // kotlin.sequences.Sequence
+            public Iterator<MenuItem> iterator() {
+                return MenuKt.iterator(menu);
+            }
+        };
+    }
+}

decompiled/sources/androidx/core/view/MenuProvider.java

@@ -0,0 +1,19 @@
+package androidx.core.view;
+
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface MenuProvider {
+    void onCreateMenu(@NonNull Menu menu, @NonNull MenuInflater menuInflater);
+
+    default void onMenuClosed(@NonNull Menu menu) {
+    }
+
+    boolean onMenuItemSelected(@NonNull MenuItem menuItem);
+
+    default void onPrepareMenu(@NonNull Menu menu) {
+    }
+}

decompiled/sources/androidx/core/view/MotionEventCompat.java

@@ -0,0 +1,241 @@
+package androidx.core.view;
+
+import android.view.MotionEvent;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+
+/* loaded from: classes.dex */
+public final class MotionEventCompat {
+
+    @Deprecated
+    public static final int ACTION_HOVER_ENTER = 9;
+
+    @Deprecated
+    public static final int ACTION_HOVER_EXIT = 10;
+
+    @Deprecated
+    public static final int ACTION_HOVER_MOVE = 7;
+
+    @Deprecated
+    public static final int ACTION_MASK = 255;
+
+    @Deprecated
+    public static final int ACTION_POINTER_DOWN = 5;
+
+    @Deprecated
+    public static final int ACTION_POINTER_INDEX_MASK = 65280;
+
+    @Deprecated
+    public static final int ACTION_POINTER_INDEX_SHIFT = 8;
+
+    @Deprecated
+    public static final int ACTION_POINTER_UP = 6;
+
+    @Deprecated
+    public static final int ACTION_SCROLL = 8;
+
+    @Deprecated
+    public static final int AXIS_BRAKE = 23;
+
+    @Deprecated
+    public static final int AXIS_DISTANCE = 24;
+
+    @Deprecated
+    public static final int AXIS_GAS = 22;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_1 = 32;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_10 = 41;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_11 = 42;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_12 = 43;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_13 = 44;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_14 = 45;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_15 = 46;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_16 = 47;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_2 = 33;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_3 = 34;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_4 = 35;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_5 = 36;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_6 = 37;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_7 = 38;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_8 = 39;
+
+    @Deprecated
+    public static final int AXIS_GENERIC_9 = 40;
+
+    @Deprecated
+    public static final int AXIS_HAT_X = 15;
+
+    @Deprecated
+    public static final int AXIS_HAT_Y = 16;
+
+    @Deprecated
+    public static final int AXIS_HSCROLL = 10;
+
+    @Deprecated
+    public static final int AXIS_LTRIGGER = 17;
+
+    @Deprecated
+    public static final int AXIS_ORIENTATION = 8;
+
+    @Deprecated
+    public static final int AXIS_PRESSURE = 2;
+    public static final int AXIS_RELATIVE_X = 27;
+    public static final int AXIS_RELATIVE_Y = 28;
+
+    @Deprecated
+    public static final int AXIS_RTRIGGER = 18;
+
+    @Deprecated
+    public static final int AXIS_RUDDER = 20;
+
+    @Deprecated
+    public static final int AXIS_RX = 12;
+
+    @Deprecated
+    public static final int AXIS_RY = 13;
+
+    @Deprecated
+    public static final int AXIS_RZ = 14;
+    public static final int AXIS_SCROLL = 26;
+
+    @Deprecated
+    public static final int AXIS_SIZE = 3;
+
+    @Deprecated
+    public static final int AXIS_THROTTLE = 19;
+
+    @Deprecated
+    public static final int AXIS_TILT = 25;
+
+    @Deprecated
+    public static final int AXIS_TOOL_MAJOR = 6;
+
+    @Deprecated
+    public static final int AXIS_TOOL_MINOR = 7;
+
+    @Deprecated
+    public static final int AXIS_TOUCH_MAJOR = 4;
+
+    @Deprecated
+    public static final int AXIS_TOUCH_MINOR = 5;
+
+    @Deprecated
+    public static final int AXIS_VSCROLL = 9;
+
+    @Deprecated
+    public static final int AXIS_WHEEL = 21;
+
+    @Deprecated
+    public static final int AXIS_X = 0;
+
+    @Deprecated
+    public static final int AXIS_Y = 1;
+
+    @Deprecated
+    public static final int AXIS_Z = 11;
+
+    @Deprecated
+    public static final int BUTTON_PRIMARY = 1;
+
+    @ReplaceWith(expression = "event.getActionMasked()")
+    @Deprecated
+    public static int getActionMasked(MotionEvent motionEvent) {
+        return motionEvent.getActionMasked();
+    }
+
+    @ReplaceWith(expression = "event.getActionIndex()")
+    @Deprecated
+    public static int getActionIndex(MotionEvent motionEvent) {
+        return motionEvent.getActionIndex();
+    }
+
+    @ReplaceWith(expression = "event.findPointerIndex(pointerId)")
+    @Deprecated
+    public static int findPointerIndex(MotionEvent motionEvent, int i) {
+        return motionEvent.findPointerIndex(i);
+    }
+
+    @ReplaceWith(expression = "event.getPointerId(pointerIndex)")
+    @Deprecated
+    public static int getPointerId(MotionEvent motionEvent, int i) {
+        return motionEvent.getPointerId(i);
+    }
+
+    @ReplaceWith(expression = "event.getX(pointerIndex)")
+    @Deprecated
+    public static float getX(MotionEvent motionEvent, int i) {
+        return motionEvent.getX(i);
+    }
+
+    @ReplaceWith(expression = "event.getY(pointerIndex)")
+    @Deprecated
+    public static float getY(MotionEvent motionEvent, int i) {
+        return motionEvent.getY(i);
+    }
+
+    @ReplaceWith(expression = "event.getPointerCount()")
+    @Deprecated
+    public static int getPointerCount(MotionEvent motionEvent) {
+        return motionEvent.getPointerCount();
+    }
+
+    @ReplaceWith(expression = "event.getSource()")
+    @Deprecated
+    public static int getSource(MotionEvent motionEvent) {
+        return motionEvent.getSource();
+    }
+
+    public static boolean isFromSource(@NonNull MotionEvent motionEvent, int i) {
+        return (motionEvent.getSource() & i) == i;
+    }
+
+    @ReplaceWith(expression = "event.getAxisValue(axis)")
+    @Deprecated
+    public static float getAxisValue(MotionEvent motionEvent, int i) {
+        return motionEvent.getAxisValue(i);
+    }
+
+    @ReplaceWith(expression = "event.getAxisValue(axis, pointerIndex)")
+    @Deprecated
+    public static float getAxisValue(MotionEvent motionEvent, int i, int i2) {
+        return motionEvent.getAxisValue(i, i2);
+    }
+
+    @ReplaceWith(expression = "event.getButtonState()")
+    @Deprecated
+    public static int getButtonState(MotionEvent motionEvent) {
+        return motionEvent.getButtonState();
+    }
+
+    private MotionEventCompat() {
+    }
+}

decompiled/sources/androidx/core/view/NestedScrollingChild.java

@@ -0,0 +1,24 @@
+package androidx.core.view;
+
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface NestedScrollingChild {
+    boolean dispatchNestedFling(float f, float f2, boolean z);
+
+    boolean dispatchNestedPreFling(float f, float f2);
+
+    boolean dispatchNestedPreScroll(int i, int i2, @Nullable int[] iArr, @Nullable int[] iArr2);
+
+    boolean dispatchNestedScroll(int i, int i2, int i3, int i4, @Nullable int[] iArr);
+
+    boolean hasNestedScrollingParent();
+
+    boolean isNestedScrollingEnabled();
+
+    void setNestedScrollingEnabled(boolean z);
+
+    boolean startNestedScroll(int i);
+
+    void stopNestedScroll();
+}

decompiled/sources/androidx/core/view/NestedScrollingChild2.java

@@ -0,0 +1,16 @@
+package androidx.core.view;
+
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface NestedScrollingChild2 extends NestedScrollingChild {
+    boolean dispatchNestedPreScroll(int i, int i2, @Nullable int[] iArr, @Nullable int[] iArr2, int i3);
+
+    boolean dispatchNestedScroll(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5);
+
+    boolean hasNestedScrollingParent(int i);
+
+    boolean startNestedScroll(int i, int i2);
+
+    void stopNestedScroll(int i);
+}

decompiled/sources/androidx/core/view/NestedScrollingChild3.java

@@ -0,0 +1,9 @@
+package androidx.core.view;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface NestedScrollingChild3 extends NestedScrollingChild2 {
+    void dispatchNestedScroll(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5, @NonNull int[] iArr2);
+}

decompiled/sources/androidx/core/view/NestedScrollingChildHelper.java

@@ -0,0 +1,220 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewParent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public class NestedScrollingChildHelper {
+    private boolean mIsNestedScrollingEnabled;
+    private ViewParent mNestedScrollingParentNonTouch;
+    private ViewParent mNestedScrollingParentTouch;
+    private int[] mTempNestedScrollConsumed;
+    private final View mView;
+
+    private ViewParent getNestedScrollingParentForType(int i) {
+        if (i == 0) {
+            return this.mNestedScrollingParentTouch;
+        }
+        if (i != 1) {
+            return null;
+        }
+        return this.mNestedScrollingParentNonTouch;
+    }
+
+    private int[] getTempNestedScrollConsumed() {
+        if (this.mTempNestedScrollConsumed == null) {
+            this.mTempNestedScrollConsumed = new int[2];
+        }
+        return this.mTempNestedScrollConsumed;
+    }
+
+    private void setNestedScrollingParentForType(int i, ViewParent viewParent) {
+        if (i == 0) {
+            this.mNestedScrollingParentTouch = viewParent;
+        } else {
+            if (i != 1) {
+                return;
+            }
+            this.mNestedScrollingParentNonTouch = viewParent;
+        }
+    }
+
+    public boolean isNestedScrollingEnabled() {
+        return this.mIsNestedScrollingEnabled;
+    }
+
+    public NestedScrollingChildHelper(@NonNull View view) {
+        this.mView = view;
+    }
+
+    public void setNestedScrollingEnabled(boolean z) {
+        if (this.mIsNestedScrollingEnabled) {
+            ViewCompat.stopNestedScroll(this.mView);
+        }
+        this.mIsNestedScrollingEnabled = z;
+    }
+
+    public boolean hasNestedScrollingParent() {
+        return hasNestedScrollingParent(0);
+    }
+
+    public boolean hasNestedScrollingParent(int i) {
+        return getNestedScrollingParentForType(i) != null;
+    }
+
+    public boolean startNestedScroll(int i) {
+        return startNestedScroll(i, 0);
+    }
+
+    public boolean startNestedScroll(int i, int i2) {
+        if (hasNestedScrollingParent(i2)) {
+            return true;
+        }
+        if (!isNestedScrollingEnabled()) {
+            return false;
+        }
+        View view = this.mView;
+        for (ViewParent parent = this.mView.getParent(); parent != null; parent = parent.getParent()) {
+            if (ViewParentCompat.onStartNestedScroll(parent, view, this.mView, i, i2)) {
+                setNestedScrollingParentForType(i2, parent);
+                ViewParentCompat.onNestedScrollAccepted(parent, view, this.mView, i, i2);
+                return true;
+            }
+            if (parent instanceof View) {
+                view = (View) parent;
+            }
+        }
+        return false;
+    }
+
+    public void stopNestedScroll() {
+        stopNestedScroll(0);
+    }
+
+    public void stopNestedScroll(int i) {
+        ViewParent nestedScrollingParentForType = getNestedScrollingParentForType(i);
+        if (nestedScrollingParentForType != null) {
+            ViewParentCompat.onStopNestedScroll(nestedScrollingParentForType, this.mView, i);
+            setNestedScrollingParentForType(i, null);
+        }
+    }
+
+    public boolean dispatchNestedScroll(int i, int i2, int i3, int i4, @Nullable int[] iArr) {
+        return dispatchNestedScrollInternal(i, i2, i3, i4, iArr, 0, null);
+    }
+
+    public boolean dispatchNestedScroll(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5) {
+        return dispatchNestedScrollInternal(i, i2, i3, i4, iArr, i5, null);
+    }
+
+    public void dispatchNestedScroll(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5, @Nullable int[] iArr2) {
+        dispatchNestedScrollInternal(i, i2, i3, i4, iArr, i5, iArr2);
+    }
+
+    private boolean dispatchNestedScrollInternal(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5, @Nullable int[] iArr2) {
+        ViewParent nestedScrollingParentForType;
+        int i6;
+        int i7;
+        int[] iArr3;
+        if (!isNestedScrollingEnabled() || (nestedScrollingParentForType = getNestedScrollingParentForType(i5)) == null) {
+            return false;
+        }
+        if (i == 0 && i2 == 0 && i3 == 0 && i4 == 0) {
+            if (iArr != null) {
+                iArr[0] = 0;
+                iArr[1] = 0;
+            }
+            return false;
+        }
+        if (iArr != null) {
+            this.mView.getLocationInWindow(iArr);
+            i6 = iArr[0];
+            i7 = iArr[1];
+        } else {
+            i6 = 0;
+            i7 = 0;
+        }
+        if (iArr2 == null) {
+            int[] tempNestedScrollConsumed = getTempNestedScrollConsumed();
+            tempNestedScrollConsumed[0] = 0;
+            tempNestedScrollConsumed[1] = 0;
+            iArr3 = tempNestedScrollConsumed;
+        } else {
+            iArr3 = iArr2;
+        }
+        ViewParentCompat.onNestedScroll(nestedScrollingParentForType, this.mView, i, i2, i3, i4, i5, iArr3);
+        if (iArr != null) {
+            this.mView.getLocationInWindow(iArr);
+            iArr[0] = iArr[0] - i6;
+            iArr[1] = iArr[1] - i7;
+        }
+        return true;
+    }
+
+    public boolean dispatchNestedPreScroll(int i, int i2, @Nullable int[] iArr, @Nullable int[] iArr2) {
+        return dispatchNestedPreScroll(i, i2, iArr, iArr2, 0);
+    }
+
+    public boolean dispatchNestedPreScroll(int i, int i2, @Nullable int[] iArr, @Nullable int[] iArr2, int i3) {
+        ViewParent nestedScrollingParentForType;
+        int i4;
+        int i5;
+        if (!isNestedScrollingEnabled() || (nestedScrollingParentForType = getNestedScrollingParentForType(i3)) == null) {
+            return false;
+        }
+        if (i == 0 && i2 == 0) {
+            if (iArr2 == null) {
+                return false;
+            }
+            iArr2[0] = 0;
+            iArr2[1] = 0;
+            return false;
+        }
+        if (iArr2 != null) {
+            this.mView.getLocationInWindow(iArr2);
+            i4 = iArr2[0];
+            i5 = iArr2[1];
+        } else {
+            i4 = 0;
+            i5 = 0;
+        }
+        if (iArr == null) {
+            iArr = getTempNestedScrollConsumed();
+        }
+        iArr[0] = 0;
+        iArr[1] = 0;
+        ViewParentCompat.onNestedPreScroll(nestedScrollingParentForType, this.mView, i, i2, iArr, i3);
+        if (iArr2 != null) {
+            this.mView.getLocationInWindow(iArr2);
+            iArr2[0] = iArr2[0] - i4;
+            iArr2[1] = iArr2[1] - i5;
+        }
+        return (iArr[0] == 0 && iArr[1] == 0) ? false : true;
+    }
+
+    public boolean dispatchNestedFling(float f, float f2, boolean z) {
+        ViewParent nestedScrollingParentForType;
+        if (!isNestedScrollingEnabled() || (nestedScrollingParentForType = getNestedScrollingParentForType(0)) == null) {
+            return false;
+        }
+        return ViewParentCompat.onNestedFling(nestedScrollingParentForType, this.mView, f, f2, z);
+    }
+
+    public boolean dispatchNestedPreFling(float f, float f2) {
+        ViewParent nestedScrollingParentForType;
+        if (!isNestedScrollingEnabled() || (nestedScrollingParentForType = getNestedScrollingParentForType(0)) == null) {
+            return false;
+        }
+        return ViewParentCompat.onNestedPreFling(nestedScrollingParentForType, this.mView, f, f2);
+    }
+
+    public void onDetachedFromWindow() {
+        ViewCompat.stopNestedScroll(this.mView);
+    }
+
+    public void onStopNestedScroll(@NonNull View view) {
+        ViewCompat.stopNestedScroll(this.mView);
+    }
+}

decompiled/sources/androidx/core/view/NestedScrollingParent.java

@@ -0,0 +1,23 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface NestedScrollingParent {
+    int getNestedScrollAxes();
+
+    boolean onNestedFling(@NonNull View view, float f, float f2, boolean z);
+
+    boolean onNestedPreFling(@NonNull View view, float f, float f2);
+
+    void onNestedPreScroll(@NonNull View view, int i, int i2, @NonNull int[] iArr);
+
+    void onNestedScroll(@NonNull View view, int i, int i2, int i3, int i4);
+
+    void onNestedScrollAccepted(@NonNull View view, @NonNull View view2, int i);
+
+    boolean onStartNestedScroll(@NonNull View view, @NonNull View view2, int i);
+
+    void onStopNestedScroll(@NonNull View view);
+}

decompiled/sources/androidx/core/view/NestedScrollingParent2.java

@@ -0,0 +1,17 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface NestedScrollingParent2 extends NestedScrollingParent {
+    void onNestedPreScroll(@NonNull View view, int i, int i2, @NonNull int[] iArr, int i3);
+
+    void onNestedScroll(@NonNull View view, int i, int i2, int i3, int i4, int i5);
+
+    void onNestedScrollAccepted(@NonNull View view, @NonNull View view2, int i, int i2);
+
+    boolean onStartNestedScroll(@NonNull View view, @NonNull View view2, int i, int i2);
+
+    void onStopNestedScroll(@NonNull View view, int i);
+}

decompiled/sources/androidx/core/view/NestedScrollingParent3.java

@@ -0,0 +1,9 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface NestedScrollingParent3 extends NestedScrollingParent2 {
+    void onNestedScroll(@NonNull View view, int i, int i2, int i3, int i4, int i5, @NonNull int[] iArr);
+}

decompiled/sources/androidx/core/view/NestedScrollingParentHelper.java

@@ -0,0 +1,42 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public class NestedScrollingParentHelper {
+    private int mNestedScrollAxesNonTouch;
+    private int mNestedScrollAxesTouch;
+
+    public int getNestedScrollAxes() {
+        return this.mNestedScrollAxesTouch | this.mNestedScrollAxesNonTouch;
+    }
+
+    public void onNestedScrollAccepted(@NonNull View view, @NonNull View view2, int i, int i2) {
+        if (i2 == 1) {
+            this.mNestedScrollAxesNonTouch = i;
+        } else {
+            this.mNestedScrollAxesTouch = i;
+        }
+    }
+
+    public void onStopNestedScroll(@NonNull View view, int i) {
+        if (i == 1) {
+            this.mNestedScrollAxesNonTouch = 0;
+        } else {
+            this.mNestedScrollAxesTouch = 0;
+        }
+    }
+
+    public NestedScrollingParentHelper(@NonNull ViewGroup viewGroup) {
+    }
+
+    public void onNestedScrollAccepted(@NonNull View view, @NonNull View view2, int i) {
+        onNestedScrollAccepted(view, view2, i, 0);
+    }
+
+    public void onStopNestedScroll(@NonNull View view) {
+        onStopNestedScroll(view, 0);
+    }
+}

decompiled/sources/androidx/core/view/OnApplyWindowInsetsListener.java

@@ -0,0 +1,10 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface OnApplyWindowInsetsListener {
+    @NonNull
+    WindowInsetsCompat onApplyWindowInsets(@NonNull View view, @NonNull WindowInsetsCompat windowInsetsCompat);
+}

decompiled/sources/androidx/core/view/OnReceiveContentListener.java

@@ -0,0 +1,11 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface OnReceiveContentListener {
+    @Nullable
+    ContentInfoCompat onReceiveContent(@NonNull View view, @NonNull ContentInfoCompat contentInfoCompat);
+}

decompiled/sources/androidx/core/view/OnReceiveContentViewBehavior.java

@@ -0,0 +1,10 @@
+package androidx.core.view;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface OnReceiveContentViewBehavior {
+    @Nullable
+    ContentInfoCompat onReceiveContent(@NonNull ContentInfoCompat contentInfoCompat);
+}

decompiled/sources/androidx/core/view/OneShotPreDrawListener.java

@@ -0,0 +1,58 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewTreeObserver;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public final class OneShotPreDrawListener implements ViewTreeObserver.OnPreDrawListener, View.OnAttachStateChangeListener {
+    private final Runnable mRunnable;
+    private final View mView;
+    private ViewTreeObserver mViewTreeObserver;
+
+    private OneShotPreDrawListener(View view, Runnable runnable) {
+        this.mView = view;
+        this.mViewTreeObserver = view.getViewTreeObserver();
+        this.mRunnable = runnable;
+    }
+
+    @NonNull
+    public static OneShotPreDrawListener add(@NonNull View view, @NonNull Runnable runnable) {
+        if (view == null) {
+            throw new NullPointerException("view == null");
+        }
+        if (runnable == null) {
+            throw new NullPointerException("runnable == null");
+        }
+        OneShotPreDrawListener oneShotPreDrawListener = new OneShotPreDrawListener(view, runnable);
+        view.getViewTreeObserver().addOnPreDrawListener(oneShotPreDrawListener);
+        view.addOnAttachStateChangeListener(oneShotPreDrawListener);
+        return oneShotPreDrawListener;
+    }
+
+    @Override // android.view.ViewTreeObserver.OnPreDrawListener
+    public boolean onPreDraw() {
+        removeListener();
+        this.mRunnable.run();
+        return true;
+    }
+
+    public void removeListener() {
+        if (this.mViewTreeObserver.isAlive()) {
+            this.mViewTreeObserver.removeOnPreDrawListener(this);
+        } else {
+            this.mView.getViewTreeObserver().removeOnPreDrawListener(this);
+        }
+        this.mView.removeOnAttachStateChangeListener(this);
+    }
+
+    @Override // android.view.View.OnAttachStateChangeListener
+    public void onViewAttachedToWindow(@NonNull View view) {
+        this.mViewTreeObserver = view.getViewTreeObserver();
+    }
+
+    @Override // android.view.View.OnAttachStateChangeListener
+    public void onViewDetachedFromWindow(@NonNull View view) {
+        removeListener();
+    }
+}

decompiled/sources/androidx/core/view/PointerIconCompat.java

@@ -0,0 +1,81 @@
+package androidx.core.view;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.view.PointerIcon;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+
+/* loaded from: classes.dex */
+public final class PointerIconCompat {
+    public static final int TYPE_ALIAS = 1010;
+    public static final int TYPE_ALL_SCROLL = 1013;
+    public static final int TYPE_ARROW = 1000;
+    public static final int TYPE_CELL = 1006;
+    public static final int TYPE_CONTEXT_MENU = 1001;
+    public static final int TYPE_COPY = 1011;
+    public static final int TYPE_CROSSHAIR = 1007;
+    public static final int TYPE_DEFAULT = 1000;
+    public static final int TYPE_GRAB = 1020;
+    public static final int TYPE_GRABBING = 1021;
+    public static final int TYPE_HAND = 1002;
+    public static final int TYPE_HELP = 1003;
+    public static final int TYPE_HORIZONTAL_DOUBLE_ARROW = 1014;
+    public static final int TYPE_NO_DROP = 1012;
+    public static final int TYPE_NULL = 0;
+    public static final int TYPE_TEXT = 1008;
+    public static final int TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW = 1017;
+    public static final int TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW = 1016;
+    public static final int TYPE_VERTICAL_DOUBLE_ARROW = 1015;
+    public static final int TYPE_VERTICAL_TEXT = 1009;
+    public static final int TYPE_WAIT = 1004;
+    public static final int TYPE_ZOOM_IN = 1018;
+    public static final int TYPE_ZOOM_OUT = 1019;
+    private final PointerIcon mPointerIcon;
+
+    @Nullable
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public Object getPointerIcon() {
+        return this.mPointerIcon;
+    }
+
+    private PointerIconCompat(PointerIcon pointerIcon) {
+        this.mPointerIcon = pointerIcon;
+    }
+
+    @NonNull
+    public static PointerIconCompat getSystemIcon(@NonNull Context context, int i) {
+        return new PointerIconCompat(Api24Impl.getSystemIcon(context, i));
+    }
+
+    @NonNull
+    public static PointerIconCompat create(@NonNull Bitmap bitmap, float f, float f2) {
+        return new PointerIconCompat(Api24Impl.create(bitmap, f, f2));
+    }
+
+    @NonNull
+    public static PointerIconCompat load(@NonNull Resources resources, int i) {
+        return new PointerIconCompat(Api24Impl.load(resources, i));
+    }
+
+    @RequiresApi(24)
+    public static class Api24Impl {
+        private Api24Impl() {
+        }
+
+        public static PointerIcon getSystemIcon(Context context, int i) {
+            return PointerIcon.getSystemIcon(context, i);
+        }
+
+        public static PointerIcon create(Bitmap bitmap, float f, float f2) {
+            return PointerIcon.create(bitmap, f, f2);
+        }
+
+        public static PointerIcon load(Resources resources, int i) {
+            return PointerIcon.load(resources, i);
+        }
+    }
+}

decompiled/sources/androidx/core/view/ScaleGestureDetectorCompat.java

@@ -0,0 +1,33 @@
+package androidx.core.view;
+
+import android.view.ScaleGestureDetector;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+
+/* loaded from: classes.dex */
+public final class ScaleGestureDetectorCompat {
+    private ScaleGestureDetectorCompat() {
+    }
+
+    @Deprecated
+    public static void setQuickScaleEnabled(Object obj, boolean z) {
+        setQuickScaleEnabled((ScaleGestureDetector) obj, z);
+    }
+
+    @ReplaceWith(expression = "scaleGestureDetector.setQuickScaleEnabled(enabled)")
+    @Deprecated
+    public static void setQuickScaleEnabled(@NonNull ScaleGestureDetector scaleGestureDetector, boolean z) {
+        scaleGestureDetector.setQuickScaleEnabled(z);
+    }
+
+    @Deprecated
+    public static boolean isQuickScaleEnabled(Object obj) {
+        return isQuickScaleEnabled((ScaleGestureDetector) obj);
+    }
+
+    @ReplaceWith(expression = "scaleGestureDetector.isQuickScaleEnabled()")
+    @Deprecated
+    public static boolean isQuickScaleEnabled(@NonNull ScaleGestureDetector scaleGestureDetector) {
+        return scaleGestureDetector.isQuickScaleEnabled();
+    }
+}

decompiled/sources/androidx/core/view/ScrollingView.java

@@ -0,0 +1,16 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public interface ScrollingView {
+    int computeHorizontalScrollExtent();
+
+    int computeHorizontalScrollOffset();
+
+    int computeHorizontalScrollRange();
+
+    int computeVerticalScrollExtent();
+
+    int computeVerticalScrollOffset();
+
+    int computeVerticalScrollRange();
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/androidx/core/view/SoftwareKeyboardControllerCompat.java

@@ -0,0 +1,170 @@
+package androidx.core.view;
+
+import android.R;
+import android.os.Build;
+import android.view.View;
+import android.view.WindowInsets;
+import android.view.WindowInsetsController;
+import android.view.inputmethod.InputMethodManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.view.SoftwareKeyboardControllerCompat;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes.dex */
+public final class SoftwareKeyboardControllerCompat {
+    private final Impl mImpl;
+
+    public static class Impl {
+        public void hide() {
+        }
+
+        public void show() {
+        }
+    }
+
+    public SoftwareKeyboardControllerCompat(@NonNull View view) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            this.mImpl = new Impl30(view);
+        } else {
+            this.mImpl = new Impl20(view);
+        }
+    }
+
+    @RequiresApi(30)
+    @Deprecated
+    public SoftwareKeyboardControllerCompat(@NonNull WindowInsetsController windowInsetsController) {
+        this.mImpl = new Impl30(windowInsetsController);
+    }
+
+    public void show() {
+        this.mImpl.show();
+    }
+
+    public void hide() {
+        this.mImpl.hide();
+    }
+
+    @RequiresApi(20)
+    public static class Impl20 extends Impl {
+
+        @Nullable
+        private final View mView;
+
+        public Impl20(@Nullable View view) {
+            this.mView = view;
+        }
+
+        @Override // androidx.core.view.SoftwareKeyboardControllerCompat.Impl
+        public void show() {
+            final View view = this.mView;
+            if (view == null) {
+                return;
+            }
+            if (view.isInEditMode() || view.onCheckIsTextEditor()) {
+                view.requestFocus();
+            } else {
+                view = view.getRootView().findFocus();
+            }
+            if (view == null) {
+                view = this.mView.getRootView().findViewById(R.id.content);
+            }
+            if (view == null || !view.hasWindowFocus()) {
+                return;
+            }
+            view.post(new Runnable() { // from class: androidx.core.view.SoftwareKeyboardControllerCompat$Impl20$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    SoftwareKeyboardControllerCompat.Impl20.lambda$show$0(view);
+                }
+            });
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ void lambda$show$0(View view) {
+            ((InputMethodManager) view.getContext().getSystemService("input_method")).showSoftInput(view, 0);
+        }
+
+        @Override // androidx.core.view.SoftwareKeyboardControllerCompat.Impl
+        public void hide() {
+            View view = this.mView;
+            if (view != null) {
+                ((InputMethodManager) view.getContext().getSystemService("input_method")).hideSoftInputFromWindow(this.mView.getWindowToken(), 0);
+            }
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Impl30 extends Impl20 {
+
+        @Nullable
+        private View mView;
+
+        @Nullable
+        private WindowInsetsController mWindowInsetsController;
+
+        public Impl30(@NonNull View view) {
+            super(view);
+            this.mView = view;
+        }
+
+        public Impl30(@Nullable WindowInsetsController windowInsetsController) {
+            super(null);
+            this.mWindowInsetsController = windowInsetsController;
+        }
+
+        @Override // androidx.core.view.SoftwareKeyboardControllerCompat.Impl20, androidx.core.view.SoftwareKeyboardControllerCompat.Impl
+        public void show() {
+            int ime;
+            View view = this.mView;
+            if (view != null && Build.VERSION.SDK_INT < 33) {
+                ((InputMethodManager) view.getContext().getSystemService("input_method")).isActive();
+            }
+            WindowInsetsController windowInsetsController = this.mWindowInsetsController;
+            if (windowInsetsController == null) {
+                View view2 = this.mView;
+                windowInsetsController = view2 != null ? view2.getWindowInsetsController() : null;
+            }
+            if (windowInsetsController != null) {
+                ime = WindowInsets.Type.ime();
+                windowInsetsController.show(ime);
+            }
+            super.show();
+        }
+
+        @Override // androidx.core.view.SoftwareKeyboardControllerCompat.Impl20, androidx.core.view.SoftwareKeyboardControllerCompat.Impl
+        public void hide() {
+            int ime;
+            View view;
+            WindowInsetsController windowInsetsController = this.mWindowInsetsController;
+            if (windowInsetsController == null) {
+                View view2 = this.mView;
+                windowInsetsController = view2 != null ? view2.getWindowInsetsController() : null;
+            }
+            if (windowInsetsController != null) {
+                final AtomicBoolean atomicBoolean = new AtomicBoolean(false);
+                WindowInsetsController.OnControllableInsetsChangedListener onControllableInsetsChangedListener = new WindowInsetsController.OnControllableInsetsChangedListener() { // from class: androidx.core.view.SoftwareKeyboardControllerCompat$Impl30$$ExternalSyntheticLambda6
+                    @Override // android.view.WindowInsetsController.OnControllableInsetsChangedListener
+                    public final void onControllableInsetsChanged(WindowInsetsController windowInsetsController2, int i) {
+                        SoftwareKeyboardControllerCompat.Impl30.lambda$hide$0(atomicBoolean, windowInsetsController2, i);
+                    }
+                };
+                windowInsetsController.addOnControllableInsetsChangedListener(onControllableInsetsChangedListener);
+                if (!atomicBoolean.get() && (view = this.mView) != null) {
+                    ((InputMethodManager) view.getContext().getSystemService("input_method")).hideSoftInputFromWindow(this.mView.getWindowToken(), 0);
+                }
+                windowInsetsController.removeOnControllableInsetsChangedListener(onControllableInsetsChangedListener);
+                ime = WindowInsets.Type.ime();
+                windowInsetsController.hide(ime);
+                return;
+            }
+            super.hide();
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public static /* synthetic */ void lambda$hide$0(AtomicBoolean atomicBoolean, WindowInsetsController windowInsetsController, int i) {
+            atomicBoolean.set((i & 8) != 0);
+        }
+    }
+}

decompiled/sources/androidx/core/view/TintableBackgroundView.java

@@ -0,0 +1,18 @@
+package androidx.core.view;
+
+import android.content.res.ColorStateList;
+import android.graphics.PorterDuff;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface TintableBackgroundView {
+    @Nullable
+    ColorStateList getSupportBackgroundTintList();
+
+    @Nullable
+    PorterDuff.Mode getSupportBackgroundTintMode();
+
+    void setSupportBackgroundTintList(@Nullable ColorStateList colorStateList);
+
+    void setSupportBackgroundTintMode(@Nullable PorterDuff.Mode mode);
+}

decompiled/sources/androidx/core/view/TreeIterator.java

@@ -0,0 +1,51 @@
+package androidx.core.view;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import kotlin.collections.CollectionsKt__MutableCollectionsKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.markers.KMappedMarker;
+
+/* loaded from: classes.dex */
+public final class TreeIterator<T> implements Iterator<T>, KMappedMarker {
+    private final Function1 getChildIterator;
+    private Iterator<? extends T> iterator;
+    private final List<Iterator<T>> stack = new ArrayList();
+
+    @Override // java.util.Iterator
+    public void remove() {
+        throw new UnsupportedOperationException("Operation is not supported for read-only collection");
+    }
+
+    public TreeIterator(Iterator<? extends T> it, Function1 function1) {
+        this.getChildIterator = function1;
+        this.iterator = it;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.iterator.hasNext();
+    }
+
+    @Override // java.util.Iterator
+    public T next() {
+        T next = this.iterator.next();
+        prepareNextIterator(next);
+        return next;
+    }
+
+    private final void prepareNextIterator(T t) {
+        Iterator<? extends T> it = (Iterator) this.getChildIterator.invoke(t);
+        if (it != null && it.hasNext()) {
+            this.stack.add(this.iterator);
+            this.iterator = it;
+        } else {
+            while (!this.iterator.hasNext() && (!this.stack.isEmpty())) {
+                this.iterator = (Iterator) CollectionsKt___CollectionsKt.last((List) this.stack);
+                CollectionsKt__MutableCollectionsKt.removeLast(this.stack);
+            }
+        }
+    }
+}

decompiled/sources/androidx/core/view/VelocityTrackerCompat.java

@@ -0,0 +1,136 @@
+package androidx.core.view;
+
+import android.os.Build;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Collections;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/* loaded from: classes.dex */
+public final class VelocityTrackerCompat {
+    private static Map<VelocityTracker, VelocityTrackerFallback> sFallbackTrackers = Collections.synchronizedMap(new WeakHashMap());
+
+    @Retention(RetentionPolicy.SOURCE)
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    public @interface VelocityTrackableMotionEventAxis {
+    }
+
+    @ReplaceWith(expression = "tracker.getXVelocity(pointerId)")
+    @Deprecated
+    public static float getXVelocity(VelocityTracker velocityTracker, int i) {
+        return velocityTracker.getXVelocity(i);
+    }
+
+    @ReplaceWith(expression = "tracker.getYVelocity(pointerId)")
+    @Deprecated
+    public static float getYVelocity(VelocityTracker velocityTracker, int i) {
+        return velocityTracker.getYVelocity(i);
+    }
+
+    public static boolean isAxisSupported(@NonNull VelocityTracker velocityTracker, int i) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.isAxisSupported(velocityTracker, i);
+        }
+        return i == 26 || i == 0 || i == 1;
+    }
+
+    public static float getAxisVelocity(@NonNull VelocityTracker velocityTracker, int i) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.getAxisVelocity(velocityTracker, i);
+        }
+        if (i == 0) {
+            return velocityTracker.getXVelocity();
+        }
+        if (i == 1) {
+            return velocityTracker.getYVelocity();
+        }
+        VelocityTrackerFallback fallbackTrackerOrNull = getFallbackTrackerOrNull(velocityTracker);
+        if (fallbackTrackerOrNull != null) {
+            return fallbackTrackerOrNull.getAxisVelocity(i);
+        }
+        return 0.0f;
+    }
+
+    public static float getAxisVelocity(@NonNull VelocityTracker velocityTracker, int i, int i2) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.getAxisVelocity(velocityTracker, i, i2);
+        }
+        if (i == 0) {
+            return velocityTracker.getXVelocity(i2);
+        }
+        if (i == 1) {
+            return velocityTracker.getYVelocity(i2);
+        }
+        return 0.0f;
+    }
+
+    public static void clear(@NonNull VelocityTracker velocityTracker) {
+        velocityTracker.clear();
+        removeFallbackForTracker(velocityTracker);
+    }
+
+    public static void recycle(@NonNull VelocityTracker velocityTracker) {
+        velocityTracker.recycle();
+        removeFallbackForTracker(velocityTracker);
+    }
+
+    public static void computeCurrentVelocity(@NonNull VelocityTracker velocityTracker, int i, float f) {
+        velocityTracker.computeCurrentVelocity(i, f);
+        VelocityTrackerFallback fallbackTrackerOrNull = getFallbackTrackerOrNull(velocityTracker);
+        if (fallbackTrackerOrNull != null) {
+            fallbackTrackerOrNull.computeCurrentVelocity(i, f);
+        }
+    }
+
+    public static void computeCurrentVelocity(@NonNull VelocityTracker velocityTracker, int i) {
+        computeCurrentVelocity(velocityTracker, i, Float.MAX_VALUE);
+    }
+
+    public static void addMovement(@NonNull VelocityTracker velocityTracker, @NonNull MotionEvent motionEvent) {
+        velocityTracker.addMovement(motionEvent);
+        if (Build.VERSION.SDK_INT < 34 && motionEvent.getSource() == 4194304) {
+            if (!sFallbackTrackers.containsKey(velocityTracker)) {
+                sFallbackTrackers.put(velocityTracker, new VelocityTrackerFallback());
+            }
+            sFallbackTrackers.get(velocityTracker).addMovement(motionEvent);
+        }
+    }
+
+    private static void removeFallbackForTracker(VelocityTracker velocityTracker) {
+        sFallbackTrackers.remove(velocityTracker);
+    }
+
+    @Nullable
+    private static VelocityTrackerFallback getFallbackTrackerOrNull(VelocityTracker velocityTracker) {
+        return sFallbackTrackers.get(velocityTracker);
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static boolean isAxisSupported(VelocityTracker velocityTracker, int i) {
+            return velocityTracker.isAxisSupported(i);
+        }
+
+        public static float getAxisVelocity(VelocityTracker velocityTracker, int i, int i2) {
+            return velocityTracker.getAxisVelocity(i, i2);
+        }
+
+        public static float getAxisVelocity(VelocityTracker velocityTracker, int i) {
+            return velocityTracker.getAxisVelocity(i);
+        }
+    }
+
+    private VelocityTrackerCompat() {
+    }
+}

decompiled/sources/androidx/core/view/VelocityTrackerFallback.java

@@ -0,0 +1,111 @@
+package androidx.core.view;
+
+import android.view.MotionEvent;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+class VelocityTrackerFallback {
+    private static final long ASSUME_POINTER_STOPPED_MS = 40;
+    private static final int HISTORY_SIZE = 20;
+    private static final long RANGE_MS = 100;
+    private final float[] mMovements = new float[20];
+    private final long[] mEventTimes = new long[20];
+    private float mLastComputedVelocity = 0.0f;
+    private int mDataPointsBufferSize = 0;
+    private int mDataPointsBufferLastUsedIndex = 0;
+
+    private void clear() {
+        this.mDataPointsBufferSize = 0;
+        this.mLastComputedVelocity = 0.0f;
+    }
+
+    public float getAxisVelocity(int i) {
+        if (i != 26) {
+            return 0.0f;
+        }
+        return this.mLastComputedVelocity;
+    }
+
+    public void addMovement(@NonNull MotionEvent motionEvent) {
+        long eventTime = motionEvent.getEventTime();
+        if (this.mDataPointsBufferSize != 0 && eventTime - this.mEventTimes[this.mDataPointsBufferLastUsedIndex] > ASSUME_POINTER_STOPPED_MS) {
+            clear();
+        }
+        int i = (this.mDataPointsBufferLastUsedIndex + 1) % 20;
+        this.mDataPointsBufferLastUsedIndex = i;
+        int i2 = this.mDataPointsBufferSize;
+        if (i2 != 20) {
+            this.mDataPointsBufferSize = i2 + 1;
+        }
+        this.mMovements[i] = motionEvent.getAxisValue(26);
+        this.mEventTimes[this.mDataPointsBufferLastUsedIndex] = eventTime;
+    }
+
+    public void computeCurrentVelocity(int i) {
+        computeCurrentVelocity(i, Float.MAX_VALUE);
+    }
+
+    public void computeCurrentVelocity(int i, float f) {
+        float currentVelocity = getCurrentVelocity() * i;
+        this.mLastComputedVelocity = currentVelocity;
+        if (currentVelocity < (-Math.abs(f))) {
+            this.mLastComputedVelocity = -Math.abs(f);
+        } else if (this.mLastComputedVelocity > Math.abs(f)) {
+            this.mLastComputedVelocity = Math.abs(f);
+        }
+    }
+
+    private float getCurrentVelocity() {
+        long[] jArr;
+        long j;
+        int i = this.mDataPointsBufferSize;
+        if (i < 2) {
+            return 0.0f;
+        }
+        int i2 = this.mDataPointsBufferLastUsedIndex;
+        int i3 = ((i2 + 20) - (i - 1)) % 20;
+        long j2 = this.mEventTimes[i2];
+        while (true) {
+            jArr = this.mEventTimes;
+            j = jArr[i3];
+            if (j2 - j <= RANGE_MS) {
+                break;
+            }
+            this.mDataPointsBufferSize--;
+            i3 = (i3 + 1) % 20;
+        }
+        int i4 = this.mDataPointsBufferSize;
+        if (i4 < 2) {
+            return 0.0f;
+        }
+        if (i4 == 2) {
+            int i5 = (i3 + 1) % 20;
+            if (j == jArr[i5]) {
+                return 0.0f;
+            }
+            return this.mMovements[i5] / (r2 - j);
+        }
+        float f = 0.0f;
+        int i6 = 0;
+        for (int i7 = 0; i7 < this.mDataPointsBufferSize - 1; i7++) {
+            int i8 = i7 + i3;
+            long[] jArr2 = this.mEventTimes;
+            long j3 = jArr2[i8 % 20];
+            int i9 = (i8 + 1) % 20;
+            if (jArr2[i9] != j3) {
+                i6++;
+                float kineticEnergyToVelocity = kineticEnergyToVelocity(f);
+                float f2 = this.mMovements[i9] / (this.mEventTimes[i9] - j3);
+                f += (f2 - kineticEnergyToVelocity) * Math.abs(f2);
+                if (i6 == 1) {
+                    f *= 0.5f;
+                }
+            }
+        }
+        return kineticEnergyToVelocity(f);
+    }
+
+    private static float kineticEnergyToVelocity(float f) {
+        return (f < 0.0f ? -1.0f : 1.0f) * ((float) Math.sqrt(Math.abs(f) * 2.0f));
+    }
+}

decompiled/sources/androidx/core/view/ViewConfigurationCompat.java

@@ -0,0 +1,187 @@
+package androidx.core.view;
+
+import android.R;
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.Build;
+import android.util.TypedValue;
+import android.view.InputDevice;
+import android.view.ViewConfiguration;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+import androidx.core.util.Supplier;
+import java.lang.reflect.Method;
+import java.util.Objects;
+
+/* loaded from: classes.dex */
+public final class ViewConfigurationCompat {
+    private static final int NO_FLING_MAX_VELOCITY = Integer.MIN_VALUE;
+    private static final int NO_FLING_MIN_VELOCITY = Integer.MAX_VALUE;
+    private static final int RESOURCE_ID_NOT_SUPPORTED = -1;
+    private static final int RESOURCE_ID_SUPPORTED_BUT_NOT_FOUND = 0;
+    private static final String TAG = "ViewConfigCompat";
+    private static Method sGetScaledScrollFactorMethod;
+
+    @ReplaceWith(expression = "config.getScaledPagingTouchSlop()")
+    @Deprecated
+    public static int getScaledPagingTouchSlop(ViewConfiguration viewConfiguration) {
+        return viewConfiguration.getScaledPagingTouchSlop();
+    }
+
+    @ReplaceWith(expression = "config.hasPermanentMenuKey()")
+    @Deprecated
+    public static boolean hasPermanentMenuKey(ViewConfiguration viewConfiguration) {
+        return viewConfiguration.hasPermanentMenuKey();
+    }
+
+    public static float getScaledHorizontalScrollFactor(@NonNull ViewConfiguration viewConfiguration, @NonNull Context context) {
+        return Api26Impl.getScaledHorizontalScrollFactor(viewConfiguration);
+    }
+
+    public static float getScaledVerticalScrollFactor(@NonNull ViewConfiguration viewConfiguration, @NonNull Context context) {
+        return Api26Impl.getScaledVerticalScrollFactor(viewConfiguration);
+    }
+
+    private static float getLegacyScrollFactor(ViewConfiguration viewConfiguration, Context context) {
+        if (sGetScaledScrollFactorMethod != null) {
+            try {
+                return ((Integer) r0.invoke(viewConfiguration, new Object[0])).intValue();
+            } catch (Exception unused) {
+            }
+        }
+        TypedValue typedValue = new TypedValue();
+        if (context.getTheme().resolveAttribute(R.attr.listPreferredItemHeight, typedValue, true)) {
+            return typedValue.getDimension(context.getResources().getDisplayMetrics());
+        }
+        return 0.0f;
+    }
+
+    public static int getScaledHoverSlop(@NonNull ViewConfiguration viewConfiguration) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.getScaledHoverSlop(viewConfiguration);
+        }
+        return viewConfiguration.getScaledTouchSlop() / 2;
+    }
+
+    public static boolean shouldShowMenuShortcutsWhenKeyboardPresent(@NonNull ViewConfiguration viewConfiguration, @NonNull Context context) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return Api28Impl.shouldShowMenuShortcutsWhenKeyboardPresent(viewConfiguration);
+        }
+        Resources resources = context.getResources();
+        int platformResId = getPlatformResId(resources, "config_showMenuShortcutsWhenKeyboardPresent", "bool");
+        return platformResId != 0 && resources.getBoolean(platformResId);
+    }
+
+    public static int getScaledMinimumFlingVelocity(@NonNull Context context, @NonNull final ViewConfiguration viewConfiguration, int i, int i2, int i3) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.getScaledMinimumFlingVelocity(viewConfiguration, i, i2, i3);
+        }
+        if (!isInputDeviceInfoValid(i, i2, i3)) {
+            return Integer.MAX_VALUE;
+        }
+        Resources resources = context.getResources();
+        int preApi34MinimumFlingVelocityResId = getPreApi34MinimumFlingVelocityResId(resources, i3, i2);
+        Objects.requireNonNull(viewConfiguration);
+        return getCompatFlingVelocityThreshold(resources, preApi34MinimumFlingVelocityResId, new Supplier() { // from class: androidx.core.view.ViewConfigurationCompat$$ExternalSyntheticLambda0
+            @Override // androidx.core.util.Supplier
+            public final Object get() {
+                return Integer.valueOf(viewConfiguration.getScaledMinimumFlingVelocity());
+            }
+        }, Integer.MAX_VALUE);
+    }
+
+    public static int getScaledMaximumFlingVelocity(@NonNull Context context, @NonNull final ViewConfiguration viewConfiguration, int i, int i2, int i3) {
+        if (Build.VERSION.SDK_INT >= 34) {
+            return Api34Impl.getScaledMaximumFlingVelocity(viewConfiguration, i, i2, i3);
+        }
+        if (!isInputDeviceInfoValid(i, i2, i3)) {
+            return Integer.MIN_VALUE;
+        }
+        Resources resources = context.getResources();
+        int preApi34MaximumFlingVelocityResId = getPreApi34MaximumFlingVelocityResId(resources, i3, i2);
+        Objects.requireNonNull(viewConfiguration);
+        return getCompatFlingVelocityThreshold(resources, preApi34MaximumFlingVelocityResId, new Supplier() { // from class: androidx.core.view.ViewConfigurationCompat$$ExternalSyntheticLambda1
+            @Override // androidx.core.util.Supplier
+            public final Object get() {
+                return Integer.valueOf(viewConfiguration.getScaledMaximumFlingVelocity());
+            }
+        }, Integer.MIN_VALUE);
+    }
+
+    private ViewConfigurationCompat() {
+    }
+
+    @RequiresApi(26)
+    public static class Api26Impl {
+        private Api26Impl() {
+        }
+
+        public static float getScaledHorizontalScrollFactor(ViewConfiguration viewConfiguration) {
+            return viewConfiguration.getScaledHorizontalScrollFactor();
+        }
+
+        public static float getScaledVerticalScrollFactor(ViewConfiguration viewConfiguration) {
+            return viewConfiguration.getScaledVerticalScrollFactor();
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static int getScaledHoverSlop(ViewConfiguration viewConfiguration) {
+            return viewConfiguration.getScaledHoverSlop();
+        }
+
+        public static boolean shouldShowMenuShortcutsWhenKeyboardPresent(ViewConfiguration viewConfiguration) {
+            return viewConfiguration.shouldShowMenuShortcutsWhenKeyboardPresent();
+        }
+    }
+
+    @RequiresApi(34)
+    public static class Api34Impl {
+        private Api34Impl() {
+        }
+
+        public static int getScaledMaximumFlingVelocity(@NonNull ViewConfiguration viewConfiguration, int i, int i2, int i3) {
+            return viewConfiguration.getScaledMaximumFlingVelocity(i, i2, i3);
+        }
+
+        public static int getScaledMinimumFlingVelocity(@NonNull ViewConfiguration viewConfiguration, int i, int i2, int i3) {
+            return viewConfiguration.getScaledMinimumFlingVelocity(i, i2, i3);
+        }
+    }
+
+    private static int getPreApi34MaximumFlingVelocityResId(Resources resources, int i, int i2) {
+        if (i == 4194304 && i2 == 26) {
+            return getPlatformResId(resources, "config_viewMaxRotaryEncoderFlingVelocity", "dimen");
+        }
+        return -1;
+    }
+
+    private static int getPreApi34MinimumFlingVelocityResId(Resources resources, int i, int i2) {
+        if (i == 4194304 && i2 == 26) {
+            return getPlatformResId(resources, "config_viewMinRotaryEncoderFlingVelocity", "dimen");
+        }
+        return -1;
+    }
+
+    private static int getPlatformResId(Resources resources, String str, String str2) {
+        return resources.getIdentifier(str, str2, "android");
+    }
+
+    private static boolean isInputDeviceInfoValid(int i, int i2, int i3) {
+        InputDevice device = InputDevice.getDevice(i);
+        return (device == null || device.getMotionRange(i2, i3) == null) ? false : true;
+    }
+
+    private static int getCompatFlingVelocityThreshold(Resources resources, int i, Supplier<Integer> supplier, int i2) {
+        int dimensionPixelSize;
+        if (i != -1) {
+            return (i == 0 || (dimensionPixelSize = resources.getDimensionPixelSize(i)) < 0) ? i2 : dimensionPixelSize;
+        }
+        return supplier.get().intValue();
+    }
+}

decompiled/sources/androidx/core/view/ViewGroupCompat.java

@@ -0,0 +1,71 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public final class ViewGroupCompat {
+    public static final int LAYOUT_MODE_CLIP_BOUNDS = 0;
+    public static final int LAYOUT_MODE_OPTICAL_BOUNDS = 1;
+
+    private ViewGroupCompat() {
+    }
+
+    @ReplaceWith(expression = "group.onRequestSendAccessibilityEvent(child, event)")
+    @Deprecated
+    public static boolean onRequestSendAccessibilityEvent(ViewGroup viewGroup, View view, AccessibilityEvent accessibilityEvent) {
+        return viewGroup.onRequestSendAccessibilityEvent(view, accessibilityEvent);
+    }
+
+    @ReplaceWith(expression = "group.setMotionEventSplittingEnabled(split)")
+    @Deprecated
+    public static void setMotionEventSplittingEnabled(ViewGroup viewGroup, boolean z) {
+        viewGroup.setMotionEventSplittingEnabled(z);
+    }
+
+    @ReplaceWith(expression = "group.getLayoutMode()")
+    @Deprecated
+    public static int getLayoutMode(@NonNull ViewGroup viewGroup) {
+        return viewGroup.getLayoutMode();
+    }
+
+    @ReplaceWith(expression = "group.setLayoutMode(mode)")
+    @Deprecated
+    public static void setLayoutMode(@NonNull ViewGroup viewGroup, int i) {
+        viewGroup.setLayoutMode(i);
+    }
+
+    public static void setTransitionGroup(@NonNull ViewGroup viewGroup, boolean z) {
+        Api21Impl.setTransitionGroup(viewGroup, z);
+    }
+
+    public static boolean isTransitionGroup(@NonNull ViewGroup viewGroup) {
+        return Api21Impl.isTransitionGroup(viewGroup);
+    }
+
+    public static int getNestedScrollAxes(@NonNull ViewGroup viewGroup) {
+        return Api21Impl.getNestedScrollAxes(viewGroup);
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static void setTransitionGroup(ViewGroup viewGroup, boolean z) {
+            viewGroup.setTransitionGroup(z);
+        }
+
+        public static boolean isTransitionGroup(ViewGroup viewGroup) {
+            return viewGroup.isTransitionGroup();
+        }
+
+        public static int getNestedScrollAxes(ViewGroup viewGroup) {
+            return viewGroup.getNestedScrollAxes();
+        }
+    }
+}

decompiled/sources/androidx/core/view/ViewGroupKt$iterator$1.java

@@ -0,0 +1,42 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewGroup;
+import java.util.Iterator;
+import kotlin.jvm.internal.markers.KMutableIterator;
+
+/* loaded from: classes.dex */
+public final class ViewGroupKt$iterator$1 implements Iterator<View>, KMutableIterator {
+    final /* synthetic */ ViewGroup $this_iterator;
+    private int index;
+
+    public ViewGroupKt$iterator$1(ViewGroup viewGroup) {
+        this.$this_iterator = viewGroup;
+    }
+
+    @Override // java.util.Iterator
+    public boolean hasNext() {
+        return this.index < this.$this_iterator.getChildCount();
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // java.util.Iterator
+    public View next() {
+        ViewGroup viewGroup = this.$this_iterator;
+        int i = this.index;
+        this.index = i + 1;
+        View childAt = viewGroup.getChildAt(i);
+        if (childAt != null) {
+            return childAt;
+        }
+        throw new IndexOutOfBoundsException();
+    }
+
+    @Override // java.util.Iterator
+    public void remove() {
+        ViewGroup viewGroup = this.$this_iterator;
+        int i = this.index - 1;
+        this.index = i;
+        viewGroup.removeViewAt(i);
+    }
+}

decompiled/sources/androidx/core/view/ViewGroupKt.java

@@ -0,0 +1,148 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.Px;
+import java.util.Iterator;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.functions.Function2;
+import kotlin.ranges.IntRange;
+import kotlin.ranges.RangesKt___RangesKt;
+import kotlin.sequences.Sequence;
+
+/* loaded from: classes.dex */
+public final class ViewGroupKt {
+    public static final View get(ViewGroup viewGroup, int i) {
+        View childAt = viewGroup.getChildAt(i);
+        if (childAt != null) {
+            return childAt;
+        }
+        throw new IndexOutOfBoundsException("Index: " + i + ", Size: " + viewGroup.getChildCount());
+    }
+
+    public static final boolean contains(ViewGroup viewGroup, View view) {
+        return viewGroup.indexOfChild(view) != -1;
+    }
+
+    public static final void plusAssign(ViewGroup viewGroup, View view) {
+        viewGroup.addView(view);
+    }
+
+    public static final void minusAssign(ViewGroup viewGroup, View view) {
+        viewGroup.removeView(view);
+    }
+
+    public static final int getSize(ViewGroup viewGroup) {
+        return viewGroup.getChildCount();
+    }
+
+    public static final boolean isEmpty(ViewGroup viewGroup) {
+        return viewGroup.getChildCount() == 0;
+    }
+
+    public static final boolean isNotEmpty(ViewGroup viewGroup) {
+        return viewGroup.getChildCount() != 0;
+    }
+
+    public static final void forEach(ViewGroup viewGroup, Function1 function1) {
+        int childCount = viewGroup.getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            function1.invoke(viewGroup.getChildAt(i));
+        }
+    }
+
+    public static final void forEachIndexed(ViewGroup viewGroup, Function2 function2) {
+        int childCount = viewGroup.getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            function2.invoke(Integer.valueOf(i), viewGroup.getChildAt(i));
+        }
+    }
+
+    public static final IntRange getIndices(ViewGroup viewGroup) {
+        IntRange until;
+        until = RangesKt___RangesKt.until(0, viewGroup.getChildCount());
+        return until;
+    }
+
+    public static final Iterator<View> iterator(ViewGroup viewGroup) {
+        return new ViewGroupKt$iterator$1(viewGroup);
+    }
+
+    public static final Sequence getChildren(final ViewGroup viewGroup) {
+        return new Sequence() { // from class: androidx.core.view.ViewGroupKt$children$1
+            @Override // kotlin.sequences.Sequence
+            public Iterator<View> iterator() {
+                return ViewGroupKt.iterator(viewGroup);
+            }
+        };
+    }
+
+    public static final Sequence getDescendants(final ViewGroup viewGroup) {
+        return new Sequence() { // from class: androidx.core.view.ViewGroupKt$special$$inlined$Sequence$1
+            @Override // kotlin.sequences.Sequence
+            public Iterator<View> iterator() {
+                return new TreeIterator(ViewGroupKt.getChildren(viewGroup).iterator(), new Function1() { // from class: androidx.core.view.ViewGroupKt$descendants$1$1
+                    @Override // kotlin.jvm.functions.Function1
+                    public final Iterator<View> invoke(View view) {
+                        Sequence children;
+                        ViewGroup viewGroup2 = view instanceof ViewGroup ? (ViewGroup) view : null;
+                        if (viewGroup2 == null || (children = ViewGroupKt.getChildren(viewGroup2)) == null) {
+                            return null;
+                        }
+                        return children.iterator();
+                    }
+                });
+            }
+        };
+    }
+
+    public static final void setMargins(ViewGroup.MarginLayoutParams marginLayoutParams, @Px int i) {
+        marginLayoutParams.setMargins(i, i, i, i);
+    }
+
+    public static /* synthetic */ void updateMargins$default(ViewGroup.MarginLayoutParams marginLayoutParams, int i, int i2, int i3, int i4, int i5, Object obj) {
+        if ((i5 & 1) != 0) {
+            i = marginLayoutParams.leftMargin;
+        }
+        if ((i5 & 2) != 0) {
+            i2 = marginLayoutParams.topMargin;
+        }
+        if ((i5 & 4) != 0) {
+            i3 = marginLayoutParams.rightMargin;
+        }
+        if ((i5 & 8) != 0) {
+            i4 = marginLayoutParams.bottomMargin;
+        }
+        marginLayoutParams.setMargins(i, i2, i3, i4);
+    }
+
+    public static final void updateMargins(ViewGroup.MarginLayoutParams marginLayoutParams, @Px int i, @Px int i2, @Px int i3, @Px int i4) {
+        marginLayoutParams.setMargins(i, i2, i3, i4);
+    }
+
+    public static /* synthetic */ void updateMarginsRelative$default(ViewGroup.MarginLayoutParams marginLayoutParams, int i, int i2, int i3, int i4, int i5, Object obj) {
+        if ((i5 & 1) != 0) {
+            i = marginLayoutParams.getMarginStart();
+        }
+        if ((i5 & 2) != 0) {
+            i2 = marginLayoutParams.topMargin;
+        }
+        if ((i5 & 4) != 0) {
+            i3 = marginLayoutParams.getMarginEnd();
+        }
+        if ((i5 & 8) != 0) {
+            i4 = marginLayoutParams.bottomMargin;
+        }
+        marginLayoutParams.setMarginStart(i);
+        marginLayoutParams.topMargin = i2;
+        marginLayoutParams.setMarginEnd(i3);
+        marginLayoutParams.bottomMargin = i4;
+    }
+
+    public static final void updateMarginsRelative(ViewGroup.MarginLayoutParams marginLayoutParams, @Px int i, @Px int i2, @Px int i3, @Px int i4) {
+        marginLayoutParams.setMarginStart(i);
+        marginLayoutParams.topMargin = i2;
+        marginLayoutParams.setMarginEnd(i3);
+        marginLayoutParams.bottomMargin = i4;
+    }
+}

decompiled/sources/androidx/core/view/ViewKt$allViews$1.java

@@ -0,0 +1,77 @@
+package androidx.core.view;
+
+import android.view.View;
+import android.view.ViewGroup;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt__IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.DebugMetadata;
+import kotlin.coroutines.jvm.internal.RestrictedSuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.sequences.Sequence;
+import kotlin.sequences.SequenceScope;
+
+@DebugMetadata(c = "androidx.core.view.ViewKt$allViews$1", f = "View.kt", l = {410, 412}, m = "invokeSuspend")
+/* loaded from: classes.dex */
+public final class ViewKt$allViews$1 extends RestrictedSuspendLambda implements Function2 {
+    final /* synthetic */ View $this_allViews;
+    private /* synthetic */ Object L$0;
+    int label;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public ViewKt$allViews$1(View view, Continuation continuation) {
+        super(2, continuation);
+        this.$this_allViews = view;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ViewKt$allViews$1 viewKt$allViews$1 = new ViewKt$allViews$1(this.$this_allViews, continuation);
+        viewKt$allViews$1.L$0 = obj;
+        return viewKt$allViews$1;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(SequenceScope sequenceScope, Continuation continuation) {
+        return ((ViewKt$allViews$1) create(sequenceScope, continuation)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended;
+        SequenceScope sequenceScope;
+        coroutine_suspended = IntrinsicsKt__IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.label;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            sequenceScope = (SequenceScope) this.L$0;
+            View view = this.$this_allViews;
+            this.L$0 = sequenceScope;
+            this.label = 1;
+            if (sequenceScope.yield(view, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                if (i != 2) {
+                    throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+                }
+                ResultKt.throwOnFailure(obj);
+                return Unit.INSTANCE;
+            }
+            sequenceScope = (SequenceScope) this.L$0;
+            ResultKt.throwOnFailure(obj);
+        }
+        View view2 = this.$this_allViews;
+        if (view2 instanceof ViewGroup) {
+            Sequence descendants = ViewGroupKt.getDescendants((ViewGroup) view2);
+            this.L$0 = null;
+            this.label = 2;
+            if (sequenceScope.yieldAll(descendants, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        }
+        return Unit.INSTANCE;
+    }
+}

decompiled/sources/androidx/core/view/ViewKt$ancestors$1.java

@@ -0,0 +1,19 @@
+package androidx.core.view;
+
+import android.view.ViewParent;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.FunctionReferenceImpl;
+
+/* loaded from: classes.dex */
+public /* synthetic */ class ViewKt$ancestors$1 extends FunctionReferenceImpl implements Function1 {
+    public static final ViewKt$ancestors$1 INSTANCE = new ViewKt$ancestors$1();
+
+    public ViewKt$ancestors$1() {
+        super(1, ViewParent.class, "getParent", "getParent()Landroid/view/ViewParent;", 0);
+    }
+
+    @Override // kotlin.jvm.functions.Function1
+    public final ViewParent invoke(ViewParent viewParent) {
+        return viewParent.getParent();
+    }
+}

decompiled/sources/androidx/core/view/ViewKt.java

@@ -0,0 +1,276 @@
+package androidx.core.view;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.annotation.Px;
+import com.google.android.gms.ads.RequestConfiguration;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+import kotlin.sequences.Sequence;
+import kotlin.sequences.SequencesKt__SequenceBuilderKt;
+import kotlin.sequences.SequencesKt__SequencesKt;
+
+@SourceDebugExtension({"SMAP\nView.kt\nKotlin\n*S Kotlin\n*F\n+ 1 View.kt\nandroidx/core/view/ViewKt\n+ 2 Bitmap.kt\nandroidx/core/graphics/BitmapKt\n*L\n1#1,415:1\n37#1,2:416\n55#1:418\n327#1,4:422\n42#2,3:419\n*S KotlinDebug\n*F\n+ 1 View.kt\nandroidx/core/view/ViewKt\n*L\n70#1:416,2\n70#1:418\n311#1:422,4\n233#1:419,3\n*E\n"})
+/* loaded from: classes.dex */
+public final class ViewKt {
+    public static final void doOnNextLayout(View view, final Function1 function1) {
+        view.addOnLayoutChangeListener(new View.OnLayoutChangeListener() { // from class: androidx.core.view.ViewKt$doOnNextLayout$1
+            @Override // android.view.View.OnLayoutChangeListener
+            public void onLayoutChange(View view2, int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
+                view2.removeOnLayoutChangeListener(this);
+                Function1.this.invoke(view2);
+            }
+        });
+    }
+
+    public static final void doOnLayout(View view, final Function1 function1) {
+        if (!view.isLaidOut() || view.isLayoutRequested()) {
+            view.addOnLayoutChangeListener(new View.OnLayoutChangeListener() { // from class: androidx.core.view.ViewKt$doOnLayout$$inlined$doOnNextLayout$1
+                @Override // android.view.View.OnLayoutChangeListener
+                public void onLayoutChange(View view2, int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8) {
+                    view2.removeOnLayoutChangeListener(this);
+                    Function1.this.invoke(view2);
+                }
+            });
+        } else {
+            function1.invoke(view);
+        }
+    }
+
+    public static final OneShotPreDrawListener doOnPreDraw(final View view, final Function1 function1) {
+        return OneShotPreDrawListener.add(view, new Runnable() { // from class: androidx.core.view.ViewKt$doOnPreDraw$1
+            @Override // java.lang.Runnable
+            public final void run() {
+                Function1.this.invoke(view);
+            }
+        });
+    }
+
+    public static final void doOnAttach(final View view, final Function1 function1) {
+        if (view.isAttachedToWindow()) {
+            function1.invoke(view);
+        } else {
+            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() { // from class: androidx.core.view.ViewKt$doOnAttach$1
+                @Override // android.view.View.OnAttachStateChangeListener
+                public void onViewDetachedFromWindow(View view2) {
+                }
+
+                @Override // android.view.View.OnAttachStateChangeListener
+                public void onViewAttachedToWindow(View view2) {
+                    view.removeOnAttachStateChangeListener(this);
+                    function1.invoke(view2);
+                }
+            });
+        }
+    }
+
+    public static final void doOnDetach(final View view, final Function1 function1) {
+        if (!view.isAttachedToWindow()) {
+            function1.invoke(view);
+        } else {
+            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() { // from class: androidx.core.view.ViewKt$doOnDetach$1
+                @Override // android.view.View.OnAttachStateChangeListener
+                public void onViewAttachedToWindow(View view2) {
+                }
+
+                @Override // android.view.View.OnAttachStateChangeListener
+                public void onViewDetachedFromWindow(View view2) {
+                    view.removeOnAttachStateChangeListener(this);
+                    function1.invoke(view2);
+                }
+            });
+        }
+    }
+
+    public static /* synthetic */ void updatePaddingRelative$default(View view, int i, int i2, int i3, int i4, int i5, Object obj) {
+        if ((i5 & 1) != 0) {
+            i = view.getPaddingStart();
+        }
+        if ((i5 & 2) != 0) {
+            i2 = view.getPaddingTop();
+        }
+        if ((i5 & 4) != 0) {
+            i3 = view.getPaddingEnd();
+        }
+        if ((i5 & 8) != 0) {
+            i4 = view.getPaddingBottom();
+        }
+        view.setPaddingRelative(i, i2, i3, i4);
+    }
+
+    public static final void updatePaddingRelative(View view, @Px int i, @Px int i2, @Px int i3, @Px int i4) {
+        view.setPaddingRelative(i, i2, i3, i4);
+    }
+
+    public static /* synthetic */ void updatePadding$default(View view, int i, int i2, int i3, int i4, int i5, Object obj) {
+        if ((i5 & 1) != 0) {
+            i = view.getPaddingLeft();
+        }
+        if ((i5 & 2) != 0) {
+            i2 = view.getPaddingTop();
+        }
+        if ((i5 & 4) != 0) {
+            i3 = view.getPaddingRight();
+        }
+        if ((i5 & 8) != 0) {
+            i4 = view.getPaddingBottom();
+        }
+        view.setPadding(i, i2, i3, i4);
+    }
+
+    public static final void updatePadding(View view, @Px int i, @Px int i2, @Px int i3, @Px int i4) {
+        view.setPadding(i, i2, i3, i4);
+    }
+
+    public static final void setPadding(View view, @Px int i) {
+        view.setPadding(i, i, i, i);
+    }
+
+    public static final Runnable postDelayed(View view, long j, final Function0 function0) {
+        Runnable runnable = new Runnable() { // from class: androidx.core.view.ViewKt$postDelayed$runnable$1
+            @Override // java.lang.Runnable
+            public final void run() {
+                Function0.this.invoke();
+            }
+        };
+        view.postDelayed(runnable, j);
+        return runnable;
+    }
+
+    public static final Runnable postOnAnimationDelayed(View view, long j, final Function0 function0) {
+        Runnable runnable = new Runnable() { // from class: androidx.core.view.ViewKt$$ExternalSyntheticLambda0
+            @Override // java.lang.Runnable
+            public final void run() {
+                Function0.this.invoke();
+            }
+        };
+        view.postOnAnimationDelayed(runnable, j);
+        return runnable;
+    }
+
+    public static /* synthetic */ Bitmap drawToBitmap$default(View view, Bitmap.Config config, int i, Object obj) {
+        if ((i & 1) != 0) {
+            config = Bitmap.Config.ARGB_8888;
+        }
+        return drawToBitmap(view, config);
+    }
+
+    public static final Bitmap drawToBitmap(View view, Bitmap.Config config) {
+        if (!view.isLaidOut()) {
+            throw new IllegalStateException("View needs to be laid out before calling drawToBitmap()");
+        }
+        Bitmap createBitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), config);
+        Canvas canvas = new Canvas(createBitmap);
+        canvas.translate(-view.getScrollX(), -view.getScrollY());
+        view.draw(canvas);
+        return createBitmap;
+    }
+
+    public static final boolean isVisible(View view) {
+        return view.getVisibility() == 0;
+    }
+
+    public static final void setVisible(View view, boolean z) {
+        view.setVisibility(z ? 0 : 8);
+    }
+
+    public static final boolean isInvisible(View view) {
+        return view.getVisibility() == 4;
+    }
+
+    public static final void setInvisible(View view, boolean z) {
+        view.setVisibility(z ? 4 : 0);
+    }
+
+    public static final boolean isGone(View view) {
+        return view.getVisibility() == 8;
+    }
+
+    public static final void setGone(View view, boolean z) {
+        view.setVisibility(z ? 8 : 0);
+    }
+
+    public static final void updateLayoutParams(View view, Function1 function1) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        if (layoutParams == null) {
+            throw new NullPointerException("null cannot be cast to non-null type android.view.ViewGroup.LayoutParams");
+        }
+        function1.invoke(layoutParams);
+        view.setLayoutParams(layoutParams);
+    }
+
+    public static final /* synthetic */ <T extends ViewGroup.LayoutParams> void updateLayoutParamsTyped(View view, Function1 function1) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        Intrinsics.reifiedOperationMarker(1, RequestConfiguration.MAX_AD_CONTENT_RATING_T);
+        function1.invoke(layoutParams);
+        view.setLayoutParams(layoutParams);
+    }
+
+    public static final int getMarginLeft(View view) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        ViewGroup.MarginLayoutParams marginLayoutParams = layoutParams instanceof ViewGroup.MarginLayoutParams ? (ViewGroup.MarginLayoutParams) layoutParams : null;
+        if (marginLayoutParams != null) {
+            return marginLayoutParams.leftMargin;
+        }
+        return 0;
+    }
+
+    public static final int getMarginTop(View view) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        ViewGroup.MarginLayoutParams marginLayoutParams = layoutParams instanceof ViewGroup.MarginLayoutParams ? (ViewGroup.MarginLayoutParams) layoutParams : null;
+        if (marginLayoutParams != null) {
+            return marginLayoutParams.topMargin;
+        }
+        return 0;
+    }
+
+    public static final int getMarginRight(View view) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        ViewGroup.MarginLayoutParams marginLayoutParams = layoutParams instanceof ViewGroup.MarginLayoutParams ? (ViewGroup.MarginLayoutParams) layoutParams : null;
+        if (marginLayoutParams != null) {
+            return marginLayoutParams.rightMargin;
+        }
+        return 0;
+    }
+
+    public static final int getMarginBottom(View view) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        ViewGroup.MarginLayoutParams marginLayoutParams = layoutParams instanceof ViewGroup.MarginLayoutParams ? (ViewGroup.MarginLayoutParams) layoutParams : null;
+        if (marginLayoutParams != null) {
+            return marginLayoutParams.bottomMargin;
+        }
+        return 0;
+    }
+
+    public static final int getMarginStart(View view) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+            return ((ViewGroup.MarginLayoutParams) layoutParams).getMarginStart();
+        }
+        return 0;
+    }
+
+    public static final int getMarginEnd(View view) {
+        ViewGroup.LayoutParams layoutParams = view.getLayoutParams();
+        if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
+            return ((ViewGroup.MarginLayoutParams) layoutParams).getMarginEnd();
+        }
+        return 0;
+    }
+
+    public static final Sequence getAncestors(View view) {
+        Sequence generateSequence;
+        generateSequence = SequencesKt__SequencesKt.generateSequence(view.getParent(), ViewKt$ancestors$1.INSTANCE);
+        return generateSequence;
+    }
+
+    public static final Sequence getAllViews(View view) {
+        Sequence sequence;
+        sequence = SequencesKt__SequenceBuilderKt.sequence(new ViewKt$allViews$1(view, null));
+        return sequence;
+    }
+}

decompiled/sources/androidx/core/view/ViewParentCompat.java

@@ -0,0 +1,194 @@
+package androidx.core.view;
+
+import android.util.Log;
+import android.view.View;
+import android.view.ViewParent;
+import android.view.accessibility.AccessibilityEvent;
+import androidx.annotation.NonNull;
+import androidx.annotation.ReplaceWith;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public final class ViewParentCompat {
+    private static final String TAG = "ViewParentCompat";
+    private static int[] sTempNestedScrollConsumed;
+
+    private ViewParentCompat() {
+    }
+
+    @ReplaceWith(expression = "parent.requestSendAccessibilityEvent(child, event)")
+    @Deprecated
+    public static boolean requestSendAccessibilityEvent(ViewParent viewParent, View view, AccessibilityEvent accessibilityEvent) {
+        return viewParent.requestSendAccessibilityEvent(view, accessibilityEvent);
+    }
+
+    public static boolean onStartNestedScroll(@NonNull ViewParent viewParent, @NonNull View view, @NonNull View view2, int i) {
+        return onStartNestedScroll(viewParent, view, view2, i, 0);
+    }
+
+    public static void onNestedScrollAccepted(@NonNull ViewParent viewParent, @NonNull View view, @NonNull View view2, int i) {
+        onNestedScrollAccepted(viewParent, view, view2, i, 0);
+    }
+
+    public static void onStopNestedScroll(@NonNull ViewParent viewParent, @NonNull View view) {
+        onStopNestedScroll(viewParent, view, 0);
+    }
+
+    public static void onNestedScroll(@NonNull ViewParent viewParent, @NonNull View view, int i, int i2, int i3, int i4) {
+        onNestedScroll(viewParent, view, i, i2, i3, i4, 0, getTempNestedScrollConsumed());
+    }
+
+    public static void onNestedScroll(@NonNull ViewParent viewParent, @NonNull View view, int i, int i2, int i3, int i4, int i5) {
+        onNestedScroll(viewParent, view, i, i2, i3, i4, i5, getTempNestedScrollConsumed());
+    }
+
+    public static void onNestedPreScroll(@NonNull ViewParent viewParent, @NonNull View view, int i, int i2, @NonNull int[] iArr) {
+        onNestedPreScroll(viewParent, view, i, i2, iArr, 0);
+    }
+
+    public static boolean onStartNestedScroll(@NonNull ViewParent viewParent, @NonNull View view, @NonNull View view2, int i, int i2) {
+        if (viewParent instanceof NestedScrollingParent2) {
+            return ((NestedScrollingParent2) viewParent).onStartNestedScroll(view, view2, i, i2);
+        }
+        if (i2 != 0) {
+            return false;
+        }
+        try {
+            return Api21Impl.onStartNestedScroll(viewParent, view, view2, i);
+        } catch (AbstractMethodError e) {
+            Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onStartNestedScroll", e);
+            return false;
+        }
+    }
+
+    public static void onNestedScrollAccepted(@NonNull ViewParent viewParent, @NonNull View view, @NonNull View view2, int i, int i2) {
+        if (viewParent instanceof NestedScrollingParent2) {
+            ((NestedScrollingParent2) viewParent).onNestedScrollAccepted(view, view2, i, i2);
+            return;
+        }
+        if (i2 == 0) {
+            try {
+                Api21Impl.onNestedScrollAccepted(viewParent, view, view2, i);
+            } catch (AbstractMethodError e) {
+                Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onNestedScrollAccepted", e);
+            }
+        }
+    }
+
+    public static void onStopNestedScroll(@NonNull ViewParent viewParent, @NonNull View view, int i) {
+        if (viewParent instanceof NestedScrollingParent2) {
+            ((NestedScrollingParent2) viewParent).onStopNestedScroll(view, i);
+            return;
+        }
+        if (i == 0) {
+            try {
+                Api21Impl.onStopNestedScroll(viewParent, view);
+            } catch (AbstractMethodError e) {
+                Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onStopNestedScroll", e);
+            }
+        }
+    }
+
+    public static void onNestedScroll(@NonNull ViewParent viewParent, @NonNull View view, int i, int i2, int i3, int i4, int i5, @NonNull int[] iArr) {
+        if (viewParent instanceof NestedScrollingParent3) {
+            ((NestedScrollingParent3) viewParent).onNestedScroll(view, i, i2, i3, i4, i5, iArr);
+            return;
+        }
+        iArr[0] = iArr[0] + i3;
+        iArr[1] = iArr[1] + i4;
+        if (viewParent instanceof NestedScrollingParent2) {
+            ((NestedScrollingParent2) viewParent).onNestedScroll(view, i, i2, i3, i4, i5);
+            return;
+        }
+        if (i5 == 0) {
+            try {
+                Api21Impl.onNestedScroll(viewParent, view, i, i2, i3, i4);
+            } catch (AbstractMethodError e) {
+                Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onNestedScroll", e);
+            }
+        }
+    }
+
+    public static void onNestedPreScroll(@NonNull ViewParent viewParent, @NonNull View view, int i, int i2, @NonNull int[] iArr, int i3) {
+        if (viewParent instanceof NestedScrollingParent2) {
+            ((NestedScrollingParent2) viewParent).onNestedPreScroll(view, i, i2, iArr, i3);
+            return;
+        }
+        if (i3 == 0) {
+            try {
+                Api21Impl.onNestedPreScroll(viewParent, view, i, i2, iArr);
+            } catch (AbstractMethodError e) {
+                Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onNestedPreScroll", e);
+            }
+        }
+    }
+
+    public static boolean onNestedFling(@NonNull ViewParent viewParent, @NonNull View view, float f, float f2, boolean z) {
+        try {
+            return Api21Impl.onNestedFling(viewParent, view, f, f2, z);
+        } catch (AbstractMethodError e) {
+            Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onNestedFling", e);
+            return false;
+        }
+    }
+
+    public static boolean onNestedPreFling(@NonNull ViewParent viewParent, @NonNull View view, float f, float f2) {
+        try {
+            return Api21Impl.onNestedPreFling(viewParent, view, f, f2);
+        } catch (AbstractMethodError e) {
+            Log.e(TAG, "ViewParent " + viewParent + " does not implement interface method onNestedPreFling", e);
+            return false;
+        }
+    }
+
+    @ReplaceWith(expression = "parent.notifySubtreeAccessibilityStateChanged(child, source, changeType)")
+    @Deprecated
+    public static void notifySubtreeAccessibilityStateChanged(@NonNull ViewParent viewParent, @NonNull View view, @NonNull View view2, int i) {
+        viewParent.notifySubtreeAccessibilityStateChanged(view, view2, i);
+    }
+
+    private static int[] getTempNestedScrollConsumed() {
+        int[] iArr = sTempNestedScrollConsumed;
+        if (iArr == null) {
+            sTempNestedScrollConsumed = new int[2];
+        } else {
+            iArr[0] = 0;
+            iArr[1] = 0;
+        }
+        return sTempNestedScrollConsumed;
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static boolean onStartNestedScroll(ViewParent viewParent, View view, View view2, int i) {
+            return viewParent.onStartNestedScroll(view, view2, i);
+        }
+
+        public static void onNestedScrollAccepted(ViewParent viewParent, View view, View view2, int i) {
+            viewParent.onNestedScrollAccepted(view, view2, i);
+        }
+
+        public static void onStopNestedScroll(ViewParent viewParent, View view) {
+            viewParent.onStopNestedScroll(view);
+        }
+
+        public static void onNestedScroll(ViewParent viewParent, View view, int i, int i2, int i3, int i4) {
+            viewParent.onNestedScroll(view, i, i2, i3, i4);
+        }
+
+        public static void onNestedPreScroll(ViewParent viewParent, View view, int i, int i2, int[] iArr) {
+            viewParent.onNestedPreScroll(view, i, i2, iArr);
+        }
+
+        public static boolean onNestedFling(ViewParent viewParent, View view, float f, float f2, boolean z) {
+            return viewParent.onNestedFling(view, f, f2, z);
+        }
+
+        public static boolean onNestedPreFling(ViewParent viewParent, View view, float f, float f2) {
+            return viewParent.onNestedPreFling(view, f, f2);
+        }
+    }
+}

decompiled/sources/androidx/core/view/ViewPropertyAnimatorCompat.java

@@ -0,0 +1,400 @@
+package androidx.core.view;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.annotation.SuppressLint;
+import android.view.View;
+import android.view.ViewPropertyAnimator;
+import android.view.animation.Interpolator;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes.dex */
+public final class ViewPropertyAnimatorCompat {
+    private final WeakReference<View> mView;
+
+    public ViewPropertyAnimatorCompat(View view) {
+        this.mView = new WeakReference<>(view);
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat setDuration(long j) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().setDuration(j);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat alpha(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().alpha(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat alphaBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().alphaBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat translationX(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().translationX(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat translationY(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().translationY(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat withEndAction(@NonNull Runnable runnable) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().withEndAction(runnable);
+        }
+        return this;
+    }
+
+    public long getDuration() {
+        View view = this.mView.get();
+        if (view != null) {
+            return view.animate().getDuration();
+        }
+        return 0L;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat setInterpolator(@Nullable Interpolator interpolator) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().setInterpolator(interpolator);
+        }
+        return this;
+    }
+
+    @Nullable
+    public Interpolator getInterpolator() {
+        View view = this.mView.get();
+        if (view != null) {
+            return (Interpolator) view.animate().getInterpolator();
+        }
+        return null;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat setStartDelay(long j) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().setStartDelay(j);
+        }
+        return this;
+    }
+
+    public long getStartDelay() {
+        View view = this.mView.get();
+        if (view != null) {
+            return view.animate().getStartDelay();
+        }
+        return 0L;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat rotation(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().rotation(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat rotationBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().rotationBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat rotationX(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().rotationX(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat rotationXBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().rotationXBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat rotationY(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().rotationY(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat rotationYBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().rotationYBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat scaleX(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().scaleX(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat scaleXBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().scaleXBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat scaleY(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().scaleY(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat scaleYBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().scaleYBy(f);
+        }
+        return this;
+    }
+
+    public void cancel() {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().cancel();
+        }
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat x(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().x(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat xBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().xBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat y(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().y(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat yBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().yBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat translationXBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().translationXBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat translationYBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().translationYBy(f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat translationZBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            Api21Impl.translationZBy(view.animate(), f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat translationZ(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            Api21Impl.translationZ(view.animate(), f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat z(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            Api21Impl.z(view.animate(), f);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat zBy(float f) {
+        View view = this.mView.get();
+        if (view != null) {
+            Api21Impl.zBy(view.animate(), f);
+        }
+        return this;
+    }
+
+    public void start() {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().start();
+        }
+    }
+
+    @NonNull
+    @SuppressLint({"WrongConstant"})
+    public ViewPropertyAnimatorCompat withLayer() {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().withLayer();
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat withStartAction(@NonNull Runnable runnable) {
+        View view = this.mView.get();
+        if (view != null) {
+            view.animate().withStartAction(runnable);
+        }
+        return this;
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat setListener(@Nullable ViewPropertyAnimatorListener viewPropertyAnimatorListener) {
+        View view = this.mView.get();
+        if (view != null) {
+            setListenerInternal(view, viewPropertyAnimatorListener);
+        }
+        return this;
+    }
+
+    private void setListenerInternal(final View view, final ViewPropertyAnimatorListener viewPropertyAnimatorListener) {
+        if (viewPropertyAnimatorListener != null) {
+            view.animate().setListener(new AnimatorListenerAdapter() { // from class: androidx.core.view.ViewPropertyAnimatorCompat.1
+                @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                public void onAnimationCancel(Animator animator) {
+                    viewPropertyAnimatorListener.onAnimationCancel(view);
+                }
+
+                @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                public void onAnimationEnd(Animator animator) {
+                    viewPropertyAnimatorListener.onAnimationEnd(view);
+                }
+
+                @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                public void onAnimationStart(Animator animator) {
+                    viewPropertyAnimatorListener.onAnimationStart(view);
+                }
+            });
+        } else {
+            view.animate().setListener(null);
+        }
+    }
+
+    @NonNull
+    public ViewPropertyAnimatorCompat setUpdateListener(@Nullable final ViewPropertyAnimatorUpdateListener viewPropertyAnimatorUpdateListener) {
+        final View view = this.mView.get();
+        if (view != null) {
+            view.animate().setUpdateListener(viewPropertyAnimatorUpdateListener != null ? new ValueAnimator.AnimatorUpdateListener() { // from class: androidx.core.view.ViewPropertyAnimatorCompat$$ExternalSyntheticLambda0
+                @Override // android.animation.ValueAnimator.AnimatorUpdateListener
+                public final void onAnimationUpdate(ValueAnimator valueAnimator) {
+                    ViewPropertyAnimatorUpdateListener.this.onAnimationUpdate(view);
+                }
+            } : null);
+        }
+        return this;
+    }
+
+    @RequiresApi(21)
+    public static class Api21Impl {
+        private Api21Impl() {
+        }
+
+        public static ViewPropertyAnimator translationZBy(ViewPropertyAnimator viewPropertyAnimator, float f) {
+            return viewPropertyAnimator.translationZBy(f);
+        }
+
+        public static ViewPropertyAnimator translationZ(ViewPropertyAnimator viewPropertyAnimator, float f) {
+            return viewPropertyAnimator.translationZ(f);
+        }
+
+        public static ViewPropertyAnimator z(ViewPropertyAnimator viewPropertyAnimator, float f) {
+            return viewPropertyAnimator.z(f);
+        }
+
+        public static ViewPropertyAnimator zBy(ViewPropertyAnimator viewPropertyAnimator, float f) {
+            return viewPropertyAnimator.zBy(f);
+        }
+    }
+}

decompiled/sources/androidx/core/view/ViewPropertyAnimatorListener.java

@@ -0,0 +1,13 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface ViewPropertyAnimatorListener {
+    void onAnimationCancel(@NonNull View view);
+
+    void onAnimationEnd(@NonNull View view);
+
+    void onAnimationStart(@NonNull View view);
+}

decompiled/sources/androidx/core/view/ViewPropertyAnimatorListenerAdapter.java

@@ -0,0 +1,19 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public class ViewPropertyAnimatorListenerAdapter implements ViewPropertyAnimatorListener {
+    @Override // androidx.core.view.ViewPropertyAnimatorListener
+    public void onAnimationCancel(@NonNull View view) {
+    }
+
+    @Override // androidx.core.view.ViewPropertyAnimatorListener
+    public void onAnimationEnd(@NonNull View view) {
+    }
+
+    @Override // androidx.core.view.ViewPropertyAnimatorListener
+    public void onAnimationStart(@NonNull View view) {
+    }
+}

decompiled/sources/androidx/core/view/ViewPropertyAnimatorUpdateListener.java

@@ -0,0 +1,9 @@
+package androidx.core.view;
+
+import android.view.View;
+import androidx.annotation.NonNull;
+
+/* loaded from: classes.dex */
+public interface ViewPropertyAnimatorUpdateListener {
+    void onAnimationUpdate(@NonNull View view);
+}

decompiled/sources/androidx/core/view/ViewStructureCompat.java

@@ -0,0 +1,64 @@
+package androidx.core.view;
+
+import android.view.ViewStructure;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public class ViewStructureCompat {
+    private final Object mWrappedObj;
+
+    @NonNull
+    @RequiresApi(23)
+    public static ViewStructureCompat toViewStructureCompat(@NonNull ViewStructure viewStructure) {
+        return new ViewStructureCompat(viewStructure);
+    }
+
+    @NonNull
+    @RequiresApi(23)
+    public ViewStructure toViewStructure() {
+        return (ViewStructure) this.mWrappedObj;
+    }
+
+    private ViewStructureCompat(@NonNull ViewStructure viewStructure) {
+        this.mWrappedObj = viewStructure;
+    }
+
+    public void setText(@NonNull CharSequence charSequence) {
+        Api23Impl.setText((ViewStructure) this.mWrappedObj, charSequence);
+    }
+
+    public void setClassName(@NonNull String str) {
+        Api23Impl.setClassName((ViewStructure) this.mWrappedObj, str);
+    }
+
+    public void setContentDescription(@NonNull CharSequence charSequence) {
+        Api23Impl.setContentDescription((ViewStructure) this.mWrappedObj, charSequence);
+    }
+
+    public void setDimens(int i, int i2, int i3, int i4, int i5, int i6) {
+        Api23Impl.setDimens((ViewStructure) this.mWrappedObj, i, i2, i3, i4, i5, i6);
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        public static void setDimens(ViewStructure viewStructure, int i, int i2, int i3, int i4, int i5, int i6) {
+            viewStructure.setDimens(i, i2, i3, i4, i5, i6);
+        }
+
+        public static void setText(ViewStructure viewStructure, CharSequence charSequence) {
+            viewStructure.setText(charSequence);
+        }
+
+        public static void setClassName(ViewStructure viewStructure, String str) {
+            viewStructure.setClassName(str);
+        }
+
+        public static void setContentDescription(ViewStructure viewStructure, CharSequence charSequence) {
+            viewStructure.setContentDescription(charSequence);
+        }
+    }
+}

decompiled/sources/androidx/core/view/WindowCompat$Api35Impl$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowCompat$Api35Impl$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/WindowCompat.java

@@ -0,0 +1,90 @@
+package androidx.core.view;
+
+import android.os.Build;
+import android.view.View;
+import android.view.Window;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+/* loaded from: classes.dex */
+public final class WindowCompat {
+    public static final int FEATURE_ACTION_BAR = 8;
+    public static final int FEATURE_ACTION_BAR_OVERLAY = 9;
+    public static final int FEATURE_ACTION_MODE_OVERLAY = 10;
+
+    private WindowCompat() {
+    }
+
+    @NonNull
+    public static <T extends View> T requireViewById(@NonNull Window window, @IdRes int i) {
+        if (Build.VERSION.SDK_INT >= 28) {
+            return (T) Api28Impl.requireViewById(window, i);
+        }
+        T t = (T) window.findViewById(i);
+        if (t != null) {
+            return t;
+        }
+        throw new IllegalArgumentException("ID does not reference a View inside this Window");
+    }
+
+    public static void setDecorFitsSystemWindows(@NonNull Window window, boolean z) {
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 35) {
+            Api35Impl.setDecorFitsSystemWindows(window, z);
+        } else if (i >= 30) {
+            Api30Impl.setDecorFitsSystemWindows(window, z);
+        } else {
+            Api16Impl.setDecorFitsSystemWindows(window, z);
+        }
+    }
+
+    @NonNull
+    public static WindowInsetsControllerCompat getInsetsController(@NonNull Window window, @NonNull View view) {
+        return new WindowInsetsControllerCompat(window, view);
+    }
+
+    public static class Api16Impl {
+        private Api16Impl() {
+        }
+
+        public static void setDecorFitsSystemWindows(@NonNull Window window, boolean z) {
+            View decorView = window.getDecorView();
+            int systemUiVisibility = decorView.getSystemUiVisibility();
+            decorView.setSystemUiVisibility(z ? systemUiVisibility & (-1793) : systemUiVisibility | 1792);
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Api30Impl {
+        private Api30Impl() {
+        }
+
+        public static void setDecorFitsSystemWindows(@NonNull Window window, boolean z) {
+            View decorView = window.getDecorView();
+            int systemUiVisibility = decorView.getSystemUiVisibility();
+            decorView.setSystemUiVisibility(z ? systemUiVisibility & (-257) : systemUiVisibility | 256);
+            window.setDecorFitsSystemWindows(z);
+        }
+    }
+
+    @RequiresApi(35)
+    public static class Api35Impl {
+        private Api35Impl() {
+        }
+
+        public static void setDecorFitsSystemWindows(@NonNull Window window, boolean z) {
+            window.setDecorFitsSystemWindows(z);
+        }
+    }
+
+    @RequiresApi(28)
+    public static class Api28Impl {
+        private Api28Impl() {
+        }
+
+        public static <T> T requireViewById(Window window, int i) {
+            return (T) window.requireViewById(i);
+        }
+    }
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline1 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline10.java

@@ -0,0 +1,11 @@
+package androidx.core.view;
+
+import android.graphics.Insets;
+import android.view.WindowInsetsAnimation;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline10 {
+    public static /* synthetic */ WindowInsetsAnimation.Bounds m(Insets insets, Insets insets2) {
+        return new WindowInsetsAnimation.Bounds(insets, insets2);
+    }
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline11.java

@@ -0,0 +1,7 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline11 {
+    public static /* synthetic */ void m() {
+    }
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline2.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline2 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline3.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline3 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline4.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline4 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline5.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline5 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline6.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline6 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline7.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline7 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline8.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline8 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline9.java

@@ -0,0 +1,11 @@
+package androidx.core.view;
+
+import android.view.WindowInsetsAnimation;
+import android.view.animation.Interpolator;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline9 {
+    public static /* synthetic */ WindowInsetsAnimation m(int i, Interpolator interpolator, long j) {
+        return new WindowInsetsAnimation(i, interpolator, j);
+    }
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat$Impl30$ProxyCallback$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,10 @@
+package androidx.core.view;
+
+import android.view.WindowInsetsAnimation;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationCompat$Impl30$ProxyCallback$$ExternalSyntheticApiModelOutline0 {
+    public static /* bridge */ /* synthetic */ WindowInsetsAnimation m(Object obj) {
+        return (WindowInsetsAnimation) obj;
+    }
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationCompat.java

@@ -0,0 +1,590 @@
+package androidx.core.view;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ValueAnimator;
+import android.annotation.SuppressLint;
+import android.os.Build;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.WindowInsets;
+import android.view.WindowInsetsAnimation;
+import android.view.WindowInsetsAnimation$Callback;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.Interpolator;
+import android.view.animation.PathInterpolator;
+import androidx.annotation.FloatRange;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RestrictTo;
+import androidx.core.R;
+import androidx.core.graphics.Insets;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.interpolator.view.animation.FastOutLinearInInterpolator;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Objects;
+
+/* loaded from: classes.dex */
+public final class WindowInsetsAnimationCompat {
+    private static final boolean DEBUG = false;
+    private static final String TAG = "WindowInsetsAnimCompat";
+    private Impl mImpl;
+
+    public WindowInsetsAnimationCompat(int i, @Nullable Interpolator interpolator, long j) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            this.mImpl = new Impl30(i, interpolator, j);
+        } else {
+            this.mImpl = new Impl21(i, interpolator, j);
+        }
+    }
+
+    @RequiresApi(30)
+    private WindowInsetsAnimationCompat(@NonNull WindowInsetsAnimation windowInsetsAnimation) {
+        this(0, null, 0L);
+        if (Build.VERSION.SDK_INT >= 30) {
+            this.mImpl = new Impl30(windowInsetsAnimation);
+        }
+    }
+
+    public int getTypeMask() {
+        return this.mImpl.getTypeMask();
+    }
+
+    @FloatRange(from = 0.0d, to = 1.0d)
+    public float getFraction() {
+        return this.mImpl.getFraction();
+    }
+
+    public float getInterpolatedFraction() {
+        return this.mImpl.getInterpolatedFraction();
+    }
+
+    @Nullable
+    public Interpolator getInterpolator() {
+        return this.mImpl.getInterpolator();
+    }
+
+    public long getDurationMillis() {
+        return this.mImpl.getDurationMillis();
+    }
+
+    public void setFraction(@FloatRange(from = 0.0d, to = 1.0d) float f) {
+        this.mImpl.setFraction(f);
+    }
+
+    @FloatRange(from = 0.0d, to = 1.0d)
+    public float getAlpha() {
+        return this.mImpl.getAlpha();
+    }
+
+    public void setAlpha(@FloatRange(from = 0.0d, to = 1.0d) float f) {
+        this.mImpl.setAlpha(f);
+    }
+
+    public static final class BoundsCompat {
+        private final Insets mLowerBound;
+        private final Insets mUpperBound;
+
+        @NonNull
+        public Insets getLowerBound() {
+            return this.mLowerBound;
+        }
+
+        @NonNull
+        public Insets getUpperBound() {
+            return this.mUpperBound;
+        }
+
+        public BoundsCompat(@NonNull Insets insets, @NonNull Insets insets2) {
+            this.mLowerBound = insets;
+            this.mUpperBound = insets2;
+        }
+
+        @RequiresApi(30)
+        private BoundsCompat(@NonNull WindowInsetsAnimation.Bounds bounds) {
+            this.mLowerBound = Impl30.getLowerBounds(bounds);
+            this.mUpperBound = Impl30.getHigherBounds(bounds);
+        }
+
+        @NonNull
+        public BoundsCompat inset(@NonNull Insets insets) {
+            return new BoundsCompat(WindowInsetsCompat.insetInsets(this.mLowerBound, insets.left, insets.top, insets.right, insets.bottom), WindowInsetsCompat.insetInsets(this.mUpperBound, insets.left, insets.top, insets.right, insets.bottom));
+        }
+
+        public String toString() {
+            return "Bounds{lower=" + this.mLowerBound + " upper=" + this.mUpperBound + "}";
+        }
+
+        @NonNull
+        @RequiresApi(30)
+        public WindowInsetsAnimation.Bounds toBounds() {
+            return Impl30.createPlatformBounds(this);
+        }
+
+        @NonNull
+        @RequiresApi(30)
+        public static BoundsCompat toBoundsCompat(@NonNull WindowInsetsAnimation.Bounds bounds) {
+            return new BoundsCompat(bounds);
+        }
+    }
+
+    @RequiresApi(30)
+    public static WindowInsetsAnimationCompat toWindowInsetsAnimationCompat(WindowInsetsAnimation windowInsetsAnimation) {
+        return new WindowInsetsAnimationCompat(windowInsetsAnimation);
+    }
+
+    public static abstract class Callback {
+        public static final int DISPATCH_MODE_CONTINUE_ON_SUBTREE = 1;
+        public static final int DISPATCH_MODE_STOP = 0;
+        WindowInsets mDispachedInsets;
+        private final int mDispatchMode;
+
+        @Retention(RetentionPolicy.SOURCE)
+        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
+        public @interface DispatchMode {
+        }
+
+        public final int getDispatchMode() {
+            return this.mDispatchMode;
+        }
+
+        public void onEnd(@NonNull WindowInsetsAnimationCompat windowInsetsAnimationCompat) {
+        }
+
+        public void onPrepare(@NonNull WindowInsetsAnimationCompat windowInsetsAnimationCompat) {
+        }
+
+        @NonNull
+        public abstract WindowInsetsCompat onProgress(@NonNull WindowInsetsCompat windowInsetsCompat, @NonNull List<WindowInsetsAnimationCompat> list);
+
+        @NonNull
+        public BoundsCompat onStart(@NonNull WindowInsetsAnimationCompat windowInsetsAnimationCompat, @NonNull BoundsCompat boundsCompat) {
+            return boundsCompat;
+        }
+
+        public Callback(int i) {
+            this.mDispatchMode = i;
+        }
+    }
+
+    public static void setCallback(@NonNull View view, @Nullable Callback callback) {
+        if (Build.VERSION.SDK_INT >= 30) {
+            Impl30.setCallback(view, callback);
+        } else {
+            Impl21.setCallback(view, callback);
+        }
+    }
+
+    public static class Impl {
+        private float mAlpha;
+        private final long mDurationMillis;
+        private float mFraction;
+
+        @Nullable
+        private final Interpolator mInterpolator;
+        private final int mTypeMask;
+
+        public float getAlpha() {
+            return this.mAlpha;
+        }
+
+        public long getDurationMillis() {
+            return this.mDurationMillis;
+        }
+
+        public float getFraction() {
+            return this.mFraction;
+        }
+
+        @Nullable
+        public Interpolator getInterpolator() {
+            return this.mInterpolator;
+        }
+
+        public int getTypeMask() {
+            return this.mTypeMask;
+        }
+
+        public void setAlpha(float f) {
+            this.mAlpha = f;
+        }
+
+        public void setFraction(float f) {
+            this.mFraction = f;
+        }
+
+        public Impl(int i, @Nullable Interpolator interpolator, long j) {
+            this.mTypeMask = i;
+            this.mInterpolator = interpolator;
+            this.mDurationMillis = j;
+        }
+
+        public float getInterpolatedFraction() {
+            Interpolator interpolator = this.mInterpolator;
+            return interpolator != null ? interpolator.getInterpolation(this.mFraction) : this.mFraction;
+        }
+    }
+
+    @RequiresApi(21)
+    public static class Impl21 extends Impl {
+        private static final Interpolator SHOW_IME_INTERPOLATOR = new PathInterpolator(0.0f, 1.1f, 0.0f, 1.0f);
+        private static final Interpolator HIDE_IME_INTERPOLATOR = new FastOutLinearInInterpolator();
+        private static final Interpolator DEFAULT_INSET_INTERPOLATOR = new DecelerateInterpolator();
+
+        public Impl21(int i, @Nullable Interpolator interpolator, long j) {
+            super(i, interpolator, j);
+        }
+
+        public static void setCallback(@NonNull View view, @Nullable Callback callback) {
+            Object tag = view.getTag(R.id.tag_on_apply_window_listener);
+            if (callback == null) {
+                view.setTag(R.id.tag_window_insets_animation_callback, null);
+                if (tag == null) {
+                    view.setOnApplyWindowInsetsListener(null);
+                    return;
+                }
+                return;
+            }
+            View.OnApplyWindowInsetsListener createProxyListener = createProxyListener(view, callback);
+            view.setTag(R.id.tag_window_insets_animation_callback, createProxyListener);
+            if (tag == null) {
+                view.setOnApplyWindowInsetsListener(createProxyListener);
+            }
+        }
+
+        @NonNull
+        private static View.OnApplyWindowInsetsListener createProxyListener(@NonNull View view, @NonNull Callback callback) {
+            return new Impl21OnApplyWindowInsetsListener(view, callback);
+        }
+
+        @NonNull
+        public static BoundsCompat computeAnimationBounds(@NonNull WindowInsetsCompat windowInsetsCompat, @NonNull WindowInsetsCompat windowInsetsCompat2, int i) {
+            Insets insets = windowInsetsCompat.getInsets(i);
+            Insets insets2 = windowInsetsCompat2.getInsets(i);
+            return new BoundsCompat(Insets.of(Math.min(insets.left, insets2.left), Math.min(insets.top, insets2.top), Math.min(insets.right, insets2.right), Math.min(insets.bottom, insets2.bottom)), Insets.of(Math.max(insets.left, insets2.left), Math.max(insets.top, insets2.top), Math.max(insets.right, insets2.right), Math.max(insets.bottom, insets2.bottom)));
+        }
+
+        @SuppressLint({"WrongConstant"})
+        public static int buildAnimationMask(@NonNull WindowInsetsCompat windowInsetsCompat, @NonNull WindowInsetsCompat windowInsetsCompat2) {
+            int i = 0;
+            for (int i2 = 1; i2 <= 256; i2 <<= 1) {
+                if (!windowInsetsCompat.getInsets(i2).equals(windowInsetsCompat2.getInsets(i2))) {
+                    i |= i2;
+                }
+            }
+            return i;
+        }
+
+        public static Interpolator createInsetInterpolator(int i, WindowInsetsCompat windowInsetsCompat, WindowInsetsCompat windowInsetsCompat2) {
+            return (i & 8) != 0 ? windowInsetsCompat.getInsets(WindowInsetsCompat.Type.ime()).bottom > windowInsetsCompat2.getInsets(WindowInsetsCompat.Type.ime()).bottom ? SHOW_IME_INTERPOLATOR : HIDE_IME_INTERPOLATOR : DEFAULT_INSET_INTERPOLATOR;
+        }
+
+        @SuppressLint({"WrongConstant"})
+        public static WindowInsetsCompat interpolateInsets(WindowInsetsCompat windowInsetsCompat, WindowInsetsCompat windowInsetsCompat2, float f, int i) {
+            WindowInsetsCompat.Builder builder = new WindowInsetsCompat.Builder(windowInsetsCompat);
+            for (int i2 = 1; i2 <= 256; i2 <<= 1) {
+                if ((i & i2) == 0) {
+                    builder.setInsets(i2, windowInsetsCompat.getInsets(i2));
+                } else {
+                    Insets insets = windowInsetsCompat.getInsets(i2);
+                    Insets insets2 = windowInsetsCompat2.getInsets(i2);
+                    float f2 = 1.0f - f;
+                    builder.setInsets(i2, WindowInsetsCompat.insetInsets(insets, (int) (((insets.left - insets2.left) * f2) + 0.5d), (int) (((insets.top - insets2.top) * f2) + 0.5d), (int) (((insets.right - insets2.right) * f2) + 0.5d), (int) (((insets.bottom - insets2.bottom) * f2) + 0.5d)));
+                }
+            }
+            return builder.build();
+        }
+
+        @RequiresApi(21)
+        public static class Impl21OnApplyWindowInsetsListener implements View.OnApplyWindowInsetsListener {
+            private static final int COMPAT_ANIMATION_DURATION = 160;
+            final Callback mCallback;
+            private WindowInsetsCompat mLastInsets;
+
+            public Impl21OnApplyWindowInsetsListener(@NonNull View view, @NonNull Callback callback) {
+                this.mCallback = callback;
+                WindowInsetsCompat rootWindowInsets = ViewCompat.getRootWindowInsets(view);
+                this.mLastInsets = rootWindowInsets != null ? new WindowInsetsCompat.Builder(rootWindowInsets).build() : null;
+            }
+
+            @Override // android.view.View.OnApplyWindowInsetsListener
+            public WindowInsets onApplyWindowInsets(final View view, WindowInsets windowInsets) {
+                if (!view.isLaidOut()) {
+                    this.mLastInsets = WindowInsetsCompat.toWindowInsetsCompat(windowInsets, view);
+                    return Impl21.forwardToViewIfNeeded(view, windowInsets);
+                }
+                final WindowInsetsCompat windowInsetsCompat = WindowInsetsCompat.toWindowInsetsCompat(windowInsets, view);
+                if (this.mLastInsets == null) {
+                    this.mLastInsets = ViewCompat.getRootWindowInsets(view);
+                }
+                if (this.mLastInsets == null) {
+                    this.mLastInsets = windowInsetsCompat;
+                    return Impl21.forwardToViewIfNeeded(view, windowInsets);
+                }
+                Callback callback = Impl21.getCallback(view);
+                if (callback != null && Objects.equals(callback.mDispachedInsets, windowInsets)) {
+                    return Impl21.forwardToViewIfNeeded(view, windowInsets);
+                }
+                final int buildAnimationMask = Impl21.buildAnimationMask(windowInsetsCompat, this.mLastInsets);
+                if (buildAnimationMask == 0) {
+                    return Impl21.forwardToViewIfNeeded(view, windowInsets);
+                }
+                final WindowInsetsCompat windowInsetsCompat2 = this.mLastInsets;
+                final WindowInsetsAnimationCompat windowInsetsAnimationCompat = new WindowInsetsAnimationCompat(buildAnimationMask, Impl21.createInsetInterpolator(buildAnimationMask, windowInsetsCompat, windowInsetsCompat2), 160L);
+                windowInsetsAnimationCompat.setFraction(0.0f);
+                final ValueAnimator duration = ValueAnimator.ofFloat(0.0f, 1.0f).setDuration(windowInsetsAnimationCompat.getDurationMillis());
+                final BoundsCompat computeAnimationBounds = Impl21.computeAnimationBounds(windowInsetsCompat, windowInsetsCompat2, buildAnimationMask);
+                Impl21.dispatchOnPrepare(view, windowInsetsAnimationCompat, windowInsets, false);
+                duration.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { // from class: androidx.core.view.WindowInsetsAnimationCompat.Impl21.Impl21OnApplyWindowInsetsListener.1
+                    @Override // android.animation.ValueAnimator.AnimatorUpdateListener
+                    public void onAnimationUpdate(ValueAnimator valueAnimator) {
+                        windowInsetsAnimationCompat.setFraction(valueAnimator.getAnimatedFraction());
+                        Impl21.dispatchOnProgress(view, Impl21.interpolateInsets(windowInsetsCompat, windowInsetsCompat2, windowInsetsAnimationCompat.getInterpolatedFraction(), buildAnimationMask), Collections.singletonList(windowInsetsAnimationCompat));
+                    }
+                });
+                duration.addListener(new AnimatorListenerAdapter() { // from class: androidx.core.view.WindowInsetsAnimationCompat.Impl21.Impl21OnApplyWindowInsetsListener.2
+                    @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                    public void onAnimationEnd(Animator animator) {
+                        windowInsetsAnimationCompat.setFraction(1.0f);
+                        Impl21.dispatchOnEnd(view, windowInsetsAnimationCompat);
+                    }
+                });
+                OneShotPreDrawListener.add(view, new Runnable() { // from class: androidx.core.view.WindowInsetsAnimationCompat.Impl21.Impl21OnApplyWindowInsetsListener.3
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        Impl21.dispatchOnStart(view, windowInsetsAnimationCompat, computeAnimationBounds);
+                        duration.start();
+                    }
+                });
+                this.mLastInsets = windowInsetsCompat;
+                return Impl21.forwardToViewIfNeeded(view, windowInsets);
+            }
+        }
+
+        @NonNull
+        public static WindowInsets forwardToViewIfNeeded(@NonNull View view, @NonNull WindowInsets windowInsets) {
+            return view.getTag(R.id.tag_on_apply_window_listener) != null ? windowInsets : view.onApplyWindowInsets(windowInsets);
+        }
+
+        public static void dispatchOnPrepare(View view, WindowInsetsAnimationCompat windowInsetsAnimationCompat, WindowInsets windowInsets, boolean z) {
+            Callback callback = getCallback(view);
+            if (callback != null) {
+                callback.mDispachedInsets = windowInsets;
+                if (!z) {
+                    callback.onPrepare(windowInsetsAnimationCompat);
+                    z = callback.getDispatchMode() == 0;
+                }
+            }
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                for (int i = 0; i < viewGroup.getChildCount(); i++) {
+                    dispatchOnPrepare(viewGroup.getChildAt(i), windowInsetsAnimationCompat, windowInsets, z);
+                }
+            }
+        }
+
+        public static void dispatchOnStart(View view, WindowInsetsAnimationCompat windowInsetsAnimationCompat, BoundsCompat boundsCompat) {
+            Callback callback = getCallback(view);
+            if (callback != null) {
+                callback.onStart(windowInsetsAnimationCompat, boundsCompat);
+                if (callback.getDispatchMode() == 0) {
+                    return;
+                }
+            }
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                for (int i = 0; i < viewGroup.getChildCount(); i++) {
+                    dispatchOnStart(viewGroup.getChildAt(i), windowInsetsAnimationCompat, boundsCompat);
+                }
+            }
+        }
+
+        public static void dispatchOnProgress(@NonNull View view, @NonNull WindowInsetsCompat windowInsetsCompat, @NonNull List<WindowInsetsAnimationCompat> list) {
+            Callback callback = getCallback(view);
+            if (callback != null) {
+                windowInsetsCompat = callback.onProgress(windowInsetsCompat, list);
+                if (callback.getDispatchMode() == 0) {
+                    return;
+                }
+            }
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                for (int i = 0; i < viewGroup.getChildCount(); i++) {
+                    dispatchOnProgress(viewGroup.getChildAt(i), windowInsetsCompat, list);
+                }
+            }
+        }
+
+        public static void dispatchOnEnd(@NonNull View view, @NonNull WindowInsetsAnimationCompat windowInsetsAnimationCompat) {
+            Callback callback = getCallback(view);
+            if (callback != null) {
+                callback.onEnd(windowInsetsAnimationCompat);
+                if (callback.getDispatchMode() == 0) {
+                    return;
+                }
+            }
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                for (int i = 0; i < viewGroup.getChildCount(); i++) {
+                    dispatchOnEnd(viewGroup.getChildAt(i), windowInsetsAnimationCompat);
+                }
+            }
+        }
+
+        @Nullable
+        public static Callback getCallback(View view) {
+            Object tag = view.getTag(R.id.tag_window_insets_animation_callback);
+            if (tag instanceof Impl21OnApplyWindowInsetsListener) {
+                return ((Impl21OnApplyWindowInsetsListener) tag).mCallback;
+            }
+            return null;
+        }
+    }
+
+    @RequiresApi(30)
+    public static class Impl30 extends Impl {
+
+        @NonNull
+        private final WindowInsetsAnimation mWrapped;
+
+        public Impl30(@NonNull WindowInsetsAnimation windowInsetsAnimation) {
+            super(0, null, 0L);
+            this.mWrapped = windowInsetsAnimation;
+        }
+
+        public Impl30(int i, Interpolator interpolator, long j) {
+            this(WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline9.m(i, interpolator, j));
+        }
+
+        @Override // androidx.core.view.WindowInsetsAnimationCompat.Impl
+        public int getTypeMask() {
+            int typeMask;
+            typeMask = this.mWrapped.getTypeMask();
+            return typeMask;
+        }
+
+        @Override // androidx.core.view.WindowInsetsAnimationCompat.Impl
+        @Nullable
+        public Interpolator getInterpolator() {
+            Interpolator interpolator;
+            interpolator = this.mWrapped.getInterpolator();
+            return interpolator;
+        }
+
+        @Override // androidx.core.view.WindowInsetsAnimationCompat.Impl
+        public long getDurationMillis() {
+            long durationMillis;
+            durationMillis = this.mWrapped.getDurationMillis();
+            return durationMillis;
+        }
+
+        @Override // androidx.core.view.WindowInsetsAnimationCompat.Impl
+        public float getFraction() {
+            float fraction;
+            fraction = this.mWrapped.getFraction();
+            return fraction;
+        }
+
+        @Override // androidx.core.view.WindowInsetsAnimationCompat.Impl
+        public void setFraction(float f) {
+            this.mWrapped.setFraction(f);
+        }
+
+        @Override // androidx.core.view.WindowInsetsAnimationCompat.Impl
+        public float getInterpolatedFraction() {
+            float interpolatedFraction;
+            interpolatedFraction = this.mWrapped.getInterpolatedFraction();
+            return interpolatedFraction;
+        }
+
+        @RequiresApi(30)
+        public static class ProxyCallback extends WindowInsetsAnimation$Callback {
+            private final HashMap<WindowInsetsAnimation, WindowInsetsAnimationCompat> mAnimations;
+            private final Callback mCompat;
+            private List<WindowInsetsAnimationCompat> mRORunningAnimations;
+            private ArrayList<WindowInsetsAnimationCompat> mTmpRunningAnimations;
+
+            public ProxyCallback(@NonNull Callback callback) {
+                super(callback.getDispatchMode());
+                this.mAnimations = new HashMap<>();
+                this.mCompat = callback;
+            }
+
+            @NonNull
+            private WindowInsetsAnimationCompat getWindowInsetsAnimationCompat(@NonNull WindowInsetsAnimation windowInsetsAnimation) {
+                WindowInsetsAnimationCompat windowInsetsAnimationCompat = this.mAnimations.get(windowInsetsAnimation);
+                if (windowInsetsAnimationCompat != null) {
+                    return windowInsetsAnimationCompat;
+                }
+                WindowInsetsAnimationCompat windowInsetsAnimationCompat2 = WindowInsetsAnimationCompat.toWindowInsetsAnimationCompat(windowInsetsAnimation);
+                this.mAnimations.put(windowInsetsAnimation, windowInsetsAnimationCompat2);
+                return windowInsetsAnimationCompat2;
+            }
+
+            public void onPrepare(@NonNull WindowInsetsAnimation windowInsetsAnimation) {
+                this.mCompat.onPrepare(getWindowInsetsAnimationCompat(windowInsetsAnimation));
+            }
+
+            @NonNull
+            public WindowInsetsAnimation.Bounds onStart(@NonNull WindowInsetsAnimation windowInsetsAnimation, @NonNull WindowInsetsAnimation.Bounds bounds) {
+                return this.mCompat.onStart(getWindowInsetsAnimationCompat(windowInsetsAnimation), BoundsCompat.toBoundsCompat(bounds)).toBounds();
+            }
+
+            @NonNull
+            public WindowInsets onProgress(@NonNull WindowInsets windowInsets, @NonNull List<WindowInsetsAnimation> list) {
+                float fraction;
+                ArrayList<WindowInsetsAnimationCompat> arrayList = this.mTmpRunningAnimations;
+                if (arrayList == null) {
+                    ArrayList<WindowInsetsAnimationCompat> arrayList2 = new ArrayList<>(list.size());
+                    this.mTmpRunningAnimations = arrayList2;
+                    this.mRORunningAnimations = Collections.unmodifiableList(arrayList2);
+                } else {
+                    arrayList.clear();
+                }
+                for (int size = list.size() - 1; size >= 0; size--) {
+                    WindowInsetsAnimation m = WindowInsetsAnimationCompat$Impl30$ProxyCallback$$ExternalSyntheticApiModelOutline0.m(list.get(size));
+                    WindowInsetsAnimationCompat windowInsetsAnimationCompat = getWindowInsetsAnimationCompat(m);
+                    fraction = m.getFraction();
+                    windowInsetsAnimationCompat.setFraction(fraction);
+                    this.mTmpRunningAnimations.add(windowInsetsAnimationCompat);
+                }
+                return this.mCompat.onProgress(WindowInsetsCompat.toWindowInsetsCompat(windowInsets), this.mRORunningAnimations).toWindowInsets();
+            }
+
+            public void onEnd(@NonNull WindowInsetsAnimation windowInsetsAnimation) {
+                this.mCompat.onEnd(getWindowInsetsAnimationCompat(windowInsetsAnimation));
+                this.mAnimations.remove(windowInsetsAnimation);
+            }
+        }
+
+        public static void setCallback(@NonNull View view, @Nullable Callback callback) {
+            view.setWindowInsetsAnimationCallback(callback != null ? new ProxyCallback(callback) : null);
+        }
+
+        @NonNull
+        public static WindowInsetsAnimation.Bounds createPlatformBounds(@NonNull BoundsCompat boundsCompat) {
+            WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline11.m();
+            return WindowInsetsAnimationCompat$Impl30$$ExternalSyntheticApiModelOutline10.m(boundsCompat.getLowerBound().toPlatformInsets(), boundsCompat.getUpperBound().toPlatformInsets());
+        }
+
+        @NonNull
+        public static Insets getLowerBounds(@NonNull WindowInsetsAnimation.Bounds bounds) {
+            android.graphics.Insets lowerBound;
+            lowerBound = bounds.getLowerBound();
+            return Insets.toCompatInsets(lowerBound);
+        }
+
+        @NonNull
+        public static Insets getHigherBounds(@NonNull WindowInsetsAnimation.Bounds bounds) {
+            android.graphics.Insets upperBound;
+            upperBound = bounds.getUpperBound();
+            return Insets.toCompatInsets(upperBound);
+        }
+    }
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationControlListenerCompat.java

@@ -0,0 +1,13 @@
+package androidx.core.view;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public interface WindowInsetsAnimationControlListenerCompat {
+    void onCancelled(@Nullable WindowInsetsAnimationControllerCompat windowInsetsAnimationControllerCompat);
+
+    void onFinished(@NonNull WindowInsetsAnimationControllerCompat windowInsetsAnimationControllerCompat);
+
+    void onReady(@NonNull WindowInsetsAnimationControllerCompat windowInsetsAnimationControllerCompat, int i);
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationControllerCompat$Impl30$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationControllerCompat$Impl30$$ExternalSyntheticApiModelOutline0 {
+}

decompiled/sources/androidx/core/view/WindowInsetsAnimationControllerCompat$Impl30$$ExternalSyntheticApiModelOutline1.java

@@ -0,0 +1,5 @@
+package androidx.core.view;
+
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class WindowInsetsAnimationControllerCompat$Impl30$$ExternalSyntheticApiModelOutline1 {
+}