Initial commit

sources/androidx/transition/AnimatorUtils.java

@@ -0,0 +1,56 @@
+package androidx.transition;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.os.Build;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+class AnimatorUtils {
+
+    interface AnimatorPauseListenerCompat {
+        void onAnimationPause(Animator animator);
+
+        void onAnimationResume(Animator animator);
+    }
+
+    static void a(Animator animator, AnimatorListenerAdapter animatorListenerAdapter) {
+        if (Build.VERSION.SDK_INT >= 19) {
+            animator.addPauseListener(animatorListenerAdapter);
+        }
+    }
+
+    static void b(Animator animator) {
+        if (Build.VERSION.SDK_INT >= 19) {
+            animator.resume();
+            return;
+        }
+        ArrayList<Animator.AnimatorListener> listeners = animator.getListeners();
+        if (listeners != null) {
+            int size = listeners.size();
+            for (int i = 0; i < size; i++) {
+                Animator.AnimatorListener animatorListener = listeners.get(i);
+                if (animatorListener instanceof AnimatorPauseListenerCompat) {
+                    ((AnimatorPauseListenerCompat) animatorListener).onAnimationResume(animator);
+                }
+            }
+        }
+    }
+
+    static void a(Animator animator) {
+        if (Build.VERSION.SDK_INT >= 19) {
+            animator.pause();
+            return;
+        }
+        ArrayList<Animator.AnimatorListener> listeners = animator.getListeners();
+        if (listeners != null) {
+            int size = listeners.size();
+            for (int i = 0; i < size; i++) {
+                Animator.AnimatorListener animatorListener = listeners.get(i);
+                if (animatorListener instanceof AnimatorPauseListenerCompat) {
+                    ((AnimatorPauseListenerCompat) animatorListener).onAnimationPause(animator);
+                }
+            }
+        }
+    }
+}

sources/androidx/transition/AutoTransition.java

@@ -0,0 +1,15 @@
+package androidx.transition;
+
+/* loaded from: classes.dex */
+public class AutoTransition extends TransitionSet {
+    public AutoTransition() {
+        v();
+    }
+
+    private void v() {
+        b(1);
+        a(new Fade(2));
+        a(new ChangeBounds());
+        a(new Fade(1));
+    }
+}

sources/androidx/transition/ChangeBounds.java

@@ -0,0 +1,378 @@
+package androidx.transition;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.AnimatorSet;
+import android.animation.ObjectAnimator;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.PointF;
+import android.graphics.Rect;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.util.Property;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.core.view.ViewCompat;
+import com.ubt.jimu.course.view.fragment.JimuMissionListFragment;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class ChangeBounds extends Transition {
+    private static final Property<ViewBounds, PointF> P;
+    private static final Property<ViewBounds, PointF> Q;
+    private static final Property<View, PointF> R;
+    private static final Property<View, PointF> S;
+    private int[] K = new int[2];
+    private boolean L = false;
+    private boolean M = false;
+    private static final String[] N = {"android:changeBounds:bounds", "android:changeBounds:clip", "android:changeBounds:parent", "android:changeBounds:windowX", "android:changeBounds:windowY"};
+    private static final Property<Drawable, PointF> O = new Property<Drawable, PointF>(PointF.class, "boundsOrigin") { // from class: androidx.transition.ChangeBounds.1
+        private Rect a = new Rect();
+
+        @Override // android.util.Property
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void set(Drawable drawable, PointF pointF) {
+            drawable.copyBounds(this.a);
+            this.a.offsetTo(Math.round(pointF.x), Math.round(pointF.y));
+            drawable.setBounds(this.a);
+        }
+
+        @Override // android.util.Property
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public PointF get(Drawable drawable) {
+            drawable.copyBounds(this.a);
+            Rect rect = this.a;
+            return new PointF(rect.left, rect.top);
+        }
+    };
+    private static final Property<View, PointF> T = new Property<View, PointF>(PointF.class, JimuMissionListFragment.POSITION) { // from class: androidx.transition.ChangeBounds.6
+        @Override // android.util.Property
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public PointF get(View view) {
+            return null;
+        }
+
+        @Override // android.util.Property
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public void set(View view, PointF pointF) {
+            int round = Math.round(pointF.x);
+            int round2 = Math.round(pointF.y);
+            ViewUtils.a(view, round, round2, view.getWidth() + round, view.getHeight() + round2);
+        }
+    };
+    private static RectEvaluator U = new RectEvaluator();
+
+    static {
+        String str = "topLeft";
+        P = new Property<ViewBounds, PointF>(PointF.class, str) { // from class: androidx.transition.ChangeBounds.2
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public PointF get(ViewBounds viewBounds) {
+                return null;
+            }
+
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void set(ViewBounds viewBounds, PointF pointF) {
+                viewBounds.b(pointF);
+            }
+        };
+        String str2 = "bottomRight";
+        Q = new Property<ViewBounds, PointF>(PointF.class, str2) { // from class: androidx.transition.ChangeBounds.3
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public PointF get(ViewBounds viewBounds) {
+                return null;
+            }
+
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void set(ViewBounds viewBounds, PointF pointF) {
+                viewBounds.a(pointF);
+            }
+        };
+        R = new Property<View, PointF>(PointF.class, str2) { // from class: androidx.transition.ChangeBounds.4
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public PointF get(View view) {
+                return null;
+            }
+
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void set(View view, PointF pointF) {
+                ViewUtils.a(view, view.getLeft(), view.getTop(), Math.round(pointF.x), Math.round(pointF.y));
+            }
+        };
+        S = new Property<View, PointF>(PointF.class, str) { // from class: androidx.transition.ChangeBounds.5
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public PointF get(View view) {
+                return null;
+            }
+
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void set(View view, PointF pointF) {
+                ViewUtils.a(view, Math.round(pointF.x), Math.round(pointF.y), view.getRight(), view.getBottom());
+            }
+        };
+    }
+
+    private void d(TransitionValues transitionValues) {
+        View view = transitionValues.b;
+        if (!ViewCompat.x(view) && view.getWidth() == 0 && view.getHeight() == 0) {
+            return;
+        }
+        transitionValues.a.put("android:changeBounds:bounds", new Rect(view.getLeft(), view.getTop(), view.getRight(), view.getBottom()));
+        transitionValues.a.put("android:changeBounds:parent", transitionValues.b.getParent());
+        if (this.M) {
+            transitionValues.b.getLocationInWindow(this.K);
+            transitionValues.a.put("android:changeBounds:windowX", Integer.valueOf(this.K[0]));
+            transitionValues.a.put("android:changeBounds:windowY", Integer.valueOf(this.K[1]));
+        }
+        if (this.L) {
+            transitionValues.a.put("android:changeBounds:clip", ViewCompat.e(view));
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public void a(TransitionValues transitionValues) {
+        d(transitionValues);
+    }
+
+    @Override // androidx.transition.Transition
+    public void c(TransitionValues transitionValues) {
+        d(transitionValues);
+    }
+
+    @Override // androidx.transition.Transition
+    public String[] r() {
+        return N;
+    }
+
+    private boolean a(View view, View view2) {
+        if (!this.M) {
+            return true;
+        }
+        TransitionValues a = a(view, true);
+        if (a == null) {
+            if (view == view2) {
+                return true;
+            }
+        } else if (view2 == a.b) {
+            return true;
+        }
+        return false;
+    }
+
+    private static class ViewBounds {
+        private int a;
+        private int b;
+        private int c;
+        private int d;
+        private View e;
+        private int f;
+        private int g;
+
+        ViewBounds(View view) {
+            this.e = view;
+        }
+
+        void a(PointF pointF) {
+            this.c = Math.round(pointF.x);
+            this.d = Math.round(pointF.y);
+            this.g++;
+            if (this.f == this.g) {
+                a();
+            }
+        }
+
+        void b(PointF pointF) {
+            this.a = Math.round(pointF.x);
+            this.b = Math.round(pointF.y);
+            this.f++;
+            if (this.f == this.g) {
+                a();
+            }
+        }
+
+        private void a() {
+            ViewUtils.a(this.e, this.a, this.b, this.c, this.d);
+            this.f = 0;
+            this.g = 0;
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public Animator a(final ViewGroup viewGroup, TransitionValues transitionValues, TransitionValues transitionValues2) {
+        int i;
+        final View view;
+        int i2;
+        Rect rect;
+        ObjectAnimator objectAnimator;
+        Animator a;
+        if (transitionValues == null || transitionValues2 == null) {
+            return null;
+        }
+        Map<String, Object> map = transitionValues.a;
+        Map<String, Object> map2 = transitionValues2.a;
+        ViewGroup viewGroup2 = (ViewGroup) map.get("android:changeBounds:parent");
+        ViewGroup viewGroup3 = (ViewGroup) map2.get("android:changeBounds:parent");
+        if (viewGroup2 == null || viewGroup3 == null) {
+            return null;
+        }
+        final View view2 = transitionValues2.b;
+        if (a(viewGroup2, viewGroup3)) {
+            Rect rect2 = (Rect) transitionValues.a.get("android:changeBounds:bounds");
+            Rect rect3 = (Rect) transitionValues2.a.get("android:changeBounds:bounds");
+            int i3 = rect2.left;
+            final int i4 = rect3.left;
+            int i5 = rect2.top;
+            final int i6 = rect3.top;
+            int i7 = rect2.right;
+            final int i8 = rect3.right;
+            int i9 = rect2.bottom;
+            final int i10 = rect3.bottom;
+            int i11 = i7 - i3;
+            int i12 = i9 - i5;
+            int i13 = i8 - i4;
+            int i14 = i10 - i6;
+            Rect rect4 = (Rect) transitionValues.a.get("android:changeBounds:clip");
+            final Rect rect5 = (Rect) transitionValues2.a.get("android:changeBounds:clip");
+            if ((i11 == 0 || i12 == 0) && (i13 == 0 || i14 == 0)) {
+                i = 0;
+            } else {
+                i = (i3 == i4 && i5 == i6) ? 0 : 1;
+                if (i7 != i8 || i9 != i10) {
+                    i++;
+                }
+            }
+            if ((rect4 != null && !rect4.equals(rect5)) || (rect4 == null && rect5 != null)) {
+                i++;
+            }
+            if (i <= 0) {
+                return null;
+            }
+            if (!this.L) {
+                view = view2;
+                ViewUtils.a(view, i3, i5, i7, i9);
+                if (i == 2) {
+                    if (i11 == i13 && i12 == i14) {
+                        a = ObjectAnimatorUtils.a(view, T, k().a(i3, i5, i4, i6));
+                    } else {
+                        final ViewBounds viewBounds = new ViewBounds(view);
+                        ObjectAnimator a2 = ObjectAnimatorUtils.a(viewBounds, P, k().a(i3, i5, i4, i6));
+                        ObjectAnimator a3 = ObjectAnimatorUtils.a(viewBounds, Q, k().a(i7, i9, i8, i10));
+                        AnimatorSet animatorSet = new AnimatorSet();
+                        animatorSet.playTogether(a2, a3);
+                        animatorSet.addListener(new AnimatorListenerAdapter(this) { // from class: androidx.transition.ChangeBounds.7
+                            private ViewBounds mViewBounds;
+
+                            {
+                                this.mViewBounds = viewBounds;
+                            }
+                        });
+                        a = animatorSet;
+                    }
+                } else if (i3 == i4 && i5 == i6) {
+                    a = ObjectAnimatorUtils.a(view, R, k().a(i7, i9, i8, i10));
+                } else {
+                    a = ObjectAnimatorUtils.a(view, S, k().a(i3, i5, i4, i6));
+                }
+            } else {
+                view = view2;
+                ViewUtils.a(view, i3, i5, Math.max(i11, i13) + i3, Math.max(i12, i14) + i5);
+                ObjectAnimator a4 = (i3 == i4 && i5 == i6) ? null : ObjectAnimatorUtils.a(view, T, k().a(i3, i5, i4, i6));
+                if (rect4 == null) {
+                    i2 = 0;
+                    rect = new Rect(0, 0, i11, i12);
+                } else {
+                    i2 = 0;
+                    rect = rect4;
+                }
+                Rect rect6 = rect5 == null ? new Rect(i2, i2, i13, i14) : rect5;
+                if (rect.equals(rect6)) {
+                    objectAnimator = null;
+                } else {
+                    ViewCompat.a(view, rect);
+                    RectEvaluator rectEvaluator = U;
+                    Object[] objArr = new Object[2];
+                    objArr[i2] = rect;
+                    objArr[1] = rect6;
+                    objectAnimator = ObjectAnimator.ofObject(view, "clipBounds", rectEvaluator, objArr);
+                    objectAnimator.addListener(new AnimatorListenerAdapter(this) { // from class: androidx.transition.ChangeBounds.8
+                        private boolean a;
+
+                        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                        public void onAnimationCancel(Animator animator) {
+                            this.a = true;
+                        }
+
+                        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                        public void onAnimationEnd(Animator animator) {
+                            if (this.a) {
+                                return;
+                            }
+                            ViewCompat.a(view, rect5);
+                            ViewUtils.a(view, i4, i6, i8, i10);
+                        }
+                    });
+                }
+                a = TransitionUtils.a(a4, objectAnimator);
+            }
+            if (view.getParent() instanceof ViewGroup) {
+                final ViewGroup viewGroup4 = (ViewGroup) view.getParent();
+                ViewGroupUtils.a(viewGroup4, true);
+                a(new TransitionListenerAdapter(this) { // from class: androidx.transition.ChangeBounds.9
+                    boolean a = false;
+
+                    @Override // androidx.transition.TransitionListenerAdapter, androidx.transition.Transition.TransitionListener
+                    public void b(Transition transition) {
+                        ViewGroupUtils.a(viewGroup4, false);
+                    }
+
+                    @Override // androidx.transition.Transition.TransitionListener
+                    public void c(Transition transition) {
+                        if (!this.a) {
+                            ViewGroupUtils.a(viewGroup4, false);
+                        }
+                        transition.b(this);
+                    }
+
+                    @Override // androidx.transition.TransitionListenerAdapter, androidx.transition.Transition.TransitionListener
+                    public void d(Transition transition) {
+                        ViewGroupUtils.a(viewGroup4, true);
+                    }
+                });
+            }
+            return a;
+        }
+        int intValue = ((Integer) transitionValues.a.get("android:changeBounds:windowX")).intValue();
+        int intValue2 = ((Integer) transitionValues.a.get("android:changeBounds:windowY")).intValue();
+        int intValue3 = ((Integer) transitionValues2.a.get("android:changeBounds:windowX")).intValue();
+        int intValue4 = ((Integer) transitionValues2.a.get("android:changeBounds:windowY")).intValue();
+        if (intValue == intValue3 && intValue2 == intValue4) {
+            return null;
+        }
+        viewGroup.getLocationInWindow(this.K);
+        Bitmap createBitmap = Bitmap.createBitmap(view2.getWidth(), view2.getHeight(), Bitmap.Config.ARGB_8888);
+        view2.draw(new Canvas(createBitmap));
+        final BitmapDrawable bitmapDrawable = new BitmapDrawable(createBitmap);
+        final float c = ViewUtils.c(view2);
+        ViewUtils.a(view2, 0.0f);
+        ViewUtils.b(viewGroup).a(bitmapDrawable);
+        PathMotion k = k();
+        int[] iArr = this.K;
+        ObjectAnimator ofPropertyValuesHolder = ObjectAnimator.ofPropertyValuesHolder(bitmapDrawable, PropertyValuesHolderUtils.a(O, k.a(intValue - iArr[0], intValue2 - iArr[1], intValue3 - iArr[0], intValue4 - iArr[1])));
+        ofPropertyValuesHolder.addListener(new AnimatorListenerAdapter(this) { // from class: androidx.transition.ChangeBounds.10
+            @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator) {
+                ViewUtils.b(viewGroup).b(bitmapDrawable);
+                ViewUtils.a(view2, c);
+            }
+        });
+        return ofPropertyValuesHolder;
+    }
+}

sources/androidx/transition/Fade.java

@@ -0,0 +1,82 @@
+package androidx.transition;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.ObjectAnimator;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.core.view.ViewCompat;
+
+/* loaded from: classes.dex */
+public class Fade extends Visibility {
+
+    private static class FadeAnimatorListener extends AnimatorListenerAdapter {
+        private final View a;
+        private boolean b = false;
+
+        FadeAnimatorListener(View view) {
+            this.a = view;
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+        public void onAnimationEnd(Animator animator) {
+            ViewUtils.a(this.a, 1.0f);
+            if (this.b) {
+                this.a.setLayerType(0, null);
+            }
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+        public void onAnimationStart(Animator animator) {
+            if (ViewCompat.u(this.a) && this.a.getLayerType() == 0) {
+                this.b = true;
+                this.a.setLayerType(2, null);
+            }
+        }
+    }
+
+    public Fade(int i) {
+        a(i);
+    }
+
+    private Animator a(final View view, float f, float f2) {
+        if (f == f2) {
+            return null;
+        }
+        ViewUtils.a(view, f);
+        ObjectAnimator ofFloat = ObjectAnimator.ofFloat(view, ViewUtils.d, f2);
+        ofFloat.addListener(new FadeAnimatorListener(view));
+        a(new TransitionListenerAdapter(this) { // from class: androidx.transition.Fade.1
+            @Override // androidx.transition.Transition.TransitionListener
+            public void c(Transition transition) {
+                ViewUtils.a(view, 1.0f);
+                ViewUtils.a(view);
+                transition.b(this);
+            }
+        });
+        return ofFloat;
+    }
+
+    @Override // androidx.transition.Visibility
+    public Animator b(ViewGroup viewGroup, View view, TransitionValues transitionValues, TransitionValues transitionValues2) {
+        ViewUtils.e(view);
+        return a(view, a(transitionValues, 1.0f), 0.0f);
+    }
+
+    @Override // androidx.transition.Visibility, androidx.transition.Transition
+    public void c(TransitionValues transitionValues) {
+        super.c(transitionValues);
+        transitionValues.a.put("android:fade:transitionAlpha", Float.valueOf(ViewUtils.c(transitionValues.b)));
+    }
+
+    @Override // androidx.transition.Visibility
+    public Animator a(ViewGroup viewGroup, View view, TransitionValues transitionValues, TransitionValues transitionValues2) {
+        float a = a(transitionValues, 0.0f);
+        return a(view, a != 1.0f ? a : 0.0f, 1.0f);
+    }
+
+    private static float a(TransitionValues transitionValues, float f) {
+        Float f2;
+        return (transitionValues == null || (f2 = (Float) transitionValues.a.get("android:fade:transitionAlpha")) == null) ? f : f2.floatValue();
+    }
+}

sources/androidx/transition/FragmentTransitionSupport.java

@@ -0,0 +1,255 @@
+package androidx.transition;
+
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.fragment.app.FragmentTransitionImpl;
+import androidx.transition.Transition;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public class FragmentTransitionSupport extends FragmentTransitionImpl {
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public boolean a(Object obj) {
+        return obj instanceof Transition;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object b(Object obj) {
+        if (obj != null) {
+            return ((Transition) obj).mo3clone();
+        }
+        return null;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object c(Object obj) {
+        if (obj == null) {
+            return null;
+        }
+        TransitionSet transitionSet = new TransitionSet();
+        transitionSet.a((Transition) obj);
+        return transitionSet;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(Object obj, ArrayList<View> arrayList) {
+        Transition transition = (Transition) obj;
+        if (transition == null) {
+            return;
+        }
+        int i = 0;
+        if (transition instanceof TransitionSet) {
+            TransitionSet transitionSet = (TransitionSet) transition;
+            int u = transitionSet.u();
+            while (i < u) {
+                a(transitionSet.a(i), arrayList);
+                i++;
+            }
+            return;
+        }
+        if (a(transition) || !FragmentTransitionImpl.a((List) transition.q())) {
+            return;
+        }
+        int size = arrayList.size();
+        while (i < size) {
+            transition.a(arrayList.get(i));
+            i++;
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void b(Object obj, View view, ArrayList<View> arrayList) {
+        TransitionSet transitionSet = (TransitionSet) obj;
+        List<View> q = transitionSet.q();
+        q.clear();
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            FragmentTransitionImpl.a(q, arrayList.get(i));
+        }
+        q.add(view);
+        arrayList.add(view);
+        a(transitionSet, arrayList);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void c(Object obj, View view) {
+        if (view != null) {
+            Rect rect = new Rect();
+            a(view, rect);
+            ((Transition) obj).a(new Transition.EpicenterCallback(this, rect) { // from class: androidx.transition.FragmentTransitionSupport.1
+            });
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object b(Object obj, Object obj2, Object obj3) {
+        TransitionSet transitionSet = new TransitionSet();
+        if (obj != null) {
+            transitionSet.a((Transition) obj);
+        }
+        if (obj2 != null) {
+            transitionSet.a((Transition) obj2);
+        }
+        if (obj3 != null) {
+            transitionSet.a((Transition) obj3);
+        }
+        return transitionSet;
+    }
+
+    private static boolean a(Transition transition) {
+        return (FragmentTransitionImpl.a((List) transition.n()) && FragmentTransitionImpl.a((List) transition.o()) && FragmentTransitionImpl.a((List) transition.p())) ? false : true;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void b(Object obj, ArrayList<View> arrayList, ArrayList<View> arrayList2) {
+        TransitionSet transitionSet = (TransitionSet) obj;
+        if (transitionSet != null) {
+            transitionSet.q().clear();
+            transitionSet.q().addAll(arrayList2);
+            a((Object) transitionSet, arrayList, arrayList2);
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(Object obj, final View view, final ArrayList<View> arrayList) {
+        ((Transition) obj).a(new Transition.TransitionListener(this) { // from class: androidx.transition.FragmentTransitionSupport.2
+            @Override // androidx.transition.Transition.TransitionListener
+            public void a(Transition transition) {
+            }
+
+            @Override // androidx.transition.Transition.TransitionListener
+            public void b(Transition transition) {
+            }
+
+            @Override // androidx.transition.Transition.TransitionListener
+            public void c(Transition transition) {
+                transition.b(this);
+                view.setVisibility(8);
+                int size = arrayList.size();
+                for (int i = 0; i < size; i++) {
+                    ((View) arrayList.get(i)).setVisibility(0);
+                }
+            }
+
+            @Override // androidx.transition.Transition.TransitionListener
+            public void d(Transition transition) {
+            }
+        });
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public Object a(Object obj, Object obj2, Object obj3) {
+        Transition transition = (Transition) obj;
+        Transition transition2 = (Transition) obj2;
+        Transition transition3 = (Transition) obj3;
+        if (transition != null && transition2 != null) {
+            TransitionSet transitionSet = new TransitionSet();
+            transitionSet.a(transition);
+            transitionSet.a(transition2);
+            transitionSet.b(1);
+            transition = transitionSet;
+        } else if (transition == null) {
+            transition = transition2 != null ? transition2 : null;
+        }
+        if (transition3 == null) {
+            return transition;
+        }
+        TransitionSet transitionSet2 = new TransitionSet();
+        if (transition != null) {
+            transitionSet2.a(transition);
+        }
+        transitionSet2.a(transition3);
+        return transitionSet2;
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void b(Object obj, View view) {
+        if (obj != null) {
+            ((Transition) obj).d(view);
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(ViewGroup viewGroup, Object obj) {
+        TransitionManager.a(viewGroup, (Transition) obj);
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(Object obj, final Object obj2, final ArrayList<View> arrayList, final Object obj3, final ArrayList<View> arrayList2, final Object obj4, final ArrayList<View> arrayList3) {
+        ((Transition) obj).a(new Transition.TransitionListener() { // from class: androidx.transition.FragmentTransitionSupport.3
+            @Override // androidx.transition.Transition.TransitionListener
+            public void a(Transition transition) {
+                Object obj5 = obj2;
+                if (obj5 != null) {
+                    FragmentTransitionSupport.this.a(obj5, arrayList, (ArrayList<View>) null);
+                }
+                Object obj6 = obj3;
+                if (obj6 != null) {
+                    FragmentTransitionSupport.this.a(obj6, arrayList2, (ArrayList<View>) null);
+                }
+                Object obj7 = obj4;
+                if (obj7 != null) {
+                    FragmentTransitionSupport.this.a(obj7, arrayList3, (ArrayList<View>) null);
+                }
+            }
+
+            @Override // androidx.transition.Transition.TransitionListener
+            public void b(Transition transition) {
+            }
+
+            @Override // androidx.transition.Transition.TransitionListener
+            public void c(Transition transition) {
+            }
+
+            @Override // androidx.transition.Transition.TransitionListener
+            public void d(Transition transition) {
+            }
+        });
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(Object obj, ArrayList<View> arrayList, ArrayList<View> arrayList2) {
+        Transition transition = (Transition) obj;
+        int i = 0;
+        if (transition instanceof TransitionSet) {
+            TransitionSet transitionSet = (TransitionSet) transition;
+            int u = transitionSet.u();
+            while (i < u) {
+                a((Object) transitionSet.a(i), arrayList, arrayList2);
+                i++;
+            }
+            return;
+        }
+        if (a(transition)) {
+            return;
+        }
+        List<View> q = transition.q();
+        if (q.size() == arrayList.size() && q.containsAll(arrayList)) {
+            int size = arrayList2 == null ? 0 : arrayList2.size();
+            while (i < size) {
+                transition.a(arrayList2.get(i));
+                i++;
+            }
+            for (int size2 = arrayList.size() - 1; size2 >= 0; size2--) {
+                transition.d(arrayList.get(size2));
+            }
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(Object obj, View view) {
+        if (obj != null) {
+            ((Transition) obj).a(view);
+        }
+    }
+
+    @Override // androidx.fragment.app.FragmentTransitionImpl
+    public void a(Object obj, Rect rect) {
+        if (obj != null) {
+            ((Transition) obj).a(new Transition.EpicenterCallback(this, rect) { // from class: androidx.transition.FragmentTransitionSupport.4
+            });
+        }
+    }
+}

sources/androidx/transition/ObjectAnimatorUtils.java

@@ -0,0 +1,15 @@
+package androidx.transition;
+
+import android.animation.ObjectAnimator;
+import android.animation.TypeConverter;
+import android.graphics.Path;
+import android.graphics.PointF;
+import android.os.Build;
+import android.util.Property;
+
+/* loaded from: classes.dex */
+class ObjectAnimatorUtils {
+    static <T> ObjectAnimator a(T t, Property<T, PointF> property, Path path) {
+        return Build.VERSION.SDK_INT >= 21 ? ObjectAnimator.ofObject(t, property, (TypeConverter) null, path) : ObjectAnimator.ofFloat(t, new PathProperty(property, path), 0.0f, 1.0f);
+    }
+}

sources/androidx/transition/PathMotion.java

@@ -0,0 +1,8 @@
+package androidx.transition;
+
+import android.graphics.Path;
+
+/* loaded from: classes.dex */
+public abstract class PathMotion {
+    public abstract Path a(float f, float f2, float f3, float f4);
+}

sources/androidx/transition/PathProperty.java

@@ -0,0 +1,49 @@
+package androidx.transition;
+
+import android.graphics.Path;
+import android.graphics.PathMeasure;
+import android.graphics.PointF;
+import android.util.Property;
+
+/* loaded from: classes.dex */
+class PathProperty<T> extends Property<T, Float> {
+    private final Property<T, PointF> a;
+    private final PathMeasure b;
+    private final float c;
+    private final float[] d;
+    private final PointF e;
+    private float f;
+
+    PathProperty(Property<T, PointF> property, Path path) {
+        super(Float.class, property.getName());
+        this.d = new float[2];
+        this.e = new PointF();
+        this.a = property;
+        this.b = new PathMeasure(path, false);
+        this.c = this.b.getLength();
+    }
+
+    @Override // android.util.Property
+    /* renamed from: a, reason: merged with bridge method [inline-methods] */
+    public void set(T t, Float f) {
+        this.f = f.floatValue();
+        this.b.getPosTan(this.c * f.floatValue(), this.d, null);
+        PointF pointF = this.e;
+        float[] fArr = this.d;
+        pointF.x = fArr[0];
+        pointF.y = fArr[1];
+        this.a.set(t, pointF);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // android.util.Property
+    public /* bridge */ /* synthetic */ Float get(Object obj) {
+        return get((PathProperty<T>) obj);
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // android.util.Property
+    public Float get(T t) {
+        return Float.valueOf(this.f);
+    }
+}

sources/androidx/transition/PropertyValuesHolderUtils.java

@@ -0,0 +1,15 @@
+package androidx.transition;
+
+import android.animation.PropertyValuesHolder;
+import android.animation.TypeConverter;
+import android.graphics.Path;
+import android.graphics.PointF;
+import android.os.Build;
+import android.util.Property;
+
+/* loaded from: classes.dex */
+class PropertyValuesHolderUtils {
+    static PropertyValuesHolder a(Property<?, PointF> property, Path path) {
+        return Build.VERSION.SDK_INT >= 21 ? PropertyValuesHolder.ofObject(property, (TypeConverter) null, path) : PropertyValuesHolder.ofFloat(new PathProperty(property, path), 0.0f, 1.0f);
+    }
+}

sources/androidx/transition/R$id.java

@@ -0,0 +1,43 @@
+package androidx.transition;
+
+/* loaded from: classes.dex */
+public final class R$id {
+    public static final int action_container = 2131296279;
+    public static final int action_divider = 2131296281;
+    public static final int action_image = 2131296282;
+    public static final int action_text = 2131296288;
+    public static final int actions = 2131296289;
+    public static final int async = 2131296326;
+    public static final int blocking = 2131296343;
+    public static final int chronometer = 2131296452;
+    public static final int forever = 2131296644;
+    public static final int ghost_view = 2131296650;
+    public static final int icon = 2131296701;
+    public static final int icon_group = 2131296702;
+    public static final int info = 2131296971;
+    public static final int italic = 2131296980;
+    public static final int line1 = 2131297087;
+    public static final int line3 = 2131297088;
+    public static final int normal = 2131297194;
+    public static final int notification_background = 2131297195;
+    public static final int notification_main_column = 2131297196;
+    public static final int notification_main_column_container = 2131297197;
+    public static final int parent_matrix = 2131297217;
+    public static final int right_icon = 2131297308;
+    public static final int right_side = 2131297309;
+    public static final int save_image_matrix = 2131297437;
+    public static final int save_non_transition_alpha = 2131297438;
+    public static final int save_scale_type = 2131297439;
+    public static final int tag_transition_group = 2131297528;
+    public static final int tag_unhandled_key_event_manager = 2131297529;
+    public static final int tag_unhandled_key_listeners = 2131297530;
+    public static final int text = 2131297537;
+    public static final int text2 = 2131297538;
+    public static final int time = 2131297551;
+    public static final int title = 2131297555;
+    public static final int transition_current_scene = 2131297572;
+    public static final int transition_layout_save = 2131297573;
+    public static final int transition_position = 2131297574;
+    public static final int transition_scene_layoutid_cache = 2131297575;
+    public static final int transition_transform = 2131297576;
+}

sources/androidx/transition/RectEvaluator.java

@@ -0,0 +1,27 @@
+package androidx.transition;
+
+import android.animation.TypeEvaluator;
+import android.graphics.Rect;
+
+/* loaded from: classes.dex */
+class RectEvaluator implements TypeEvaluator<Rect> {
+    private Rect a;
+
+    RectEvaluator() {
+    }
+
+    @Override // android.animation.TypeEvaluator
+    /* renamed from: a, reason: merged with bridge method [inline-methods] */
+    public Rect evaluate(float f, Rect rect, Rect rect2) {
+        int i = rect.left + ((int) ((rect2.left - r0) * f));
+        int i2 = rect.top + ((int) ((rect2.top - r1) * f));
+        int i3 = rect.right + ((int) ((rect2.right - r2) * f));
+        int i4 = rect.bottom + ((int) ((rect2.bottom - r6) * f));
+        Rect rect3 = this.a;
+        if (rect3 == null) {
+            return new Rect(i, i2, i3, i4);
+        }
+        rect3.set(i, i2, i3, i4);
+        return this.a;
+    }
+}

sources/androidx/transition/Scene.java

@@ -0,0 +1,26 @@
+package androidx.transition;
+
+import android.view.View;
+import android.view.ViewGroup;
+
+/* loaded from: classes.dex */
+public class Scene {
+    private ViewGroup a;
+    private Runnable b;
+
+    public void a() {
+        Runnable runnable;
+        if (a(this.a) != this || (runnable = this.b) == null) {
+            return;
+        }
+        runnable.run();
+    }
+
+    static void a(View view, Scene scene) {
+        view.setTag(R$id.transition_current_scene, scene);
+    }
+
+    static Scene a(View view) {
+        return (Scene) view.getTag(R$id.transition_current_scene);
+    }
+}

sources/androidx/transition/Transition.java

@@ -0,0 +1,966 @@
+package androidx.transition;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.TimeInterpolator;
+import android.graphics.Path;
+import android.util.SparseArray;
+import android.util.SparseIntArray;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ListView;
+import androidx.collection.ArrayMap;
+import androidx.collection.LongSparseArray;
+import androidx.core.view.ViewCompat;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes.dex */
+public abstract class Transition implements Cloneable {
+    private static final int[] H = {2, 1, 3, 4};
+    private static final PathMotion I = new PathMotion() { // from class: androidx.transition.Transition.1
+        @Override // androidx.transition.PathMotion
+        public Path a(float f, float f2, float f3, float f4) {
+            Path path = new Path();
+            path.moveTo(f, f2);
+            path.lineTo(f3, f4);
+            return path;
+        }
+    };
+    private static ThreadLocal<ArrayMap<Animator, AnimationInfo>> J = new ThreadLocal<>();
+    TransitionPropagation D;
+    private EpicenterCallback E;
+    private ArrayMap<String, String> F;
+    private ArrayList<TransitionValues> t;
+    private ArrayList<TransitionValues> u;
+    private String a = getClass().getName();
+    private long b = -1;
+    long c = -1;
+    private TimeInterpolator d = null;
+    ArrayList<Integer> e = new ArrayList<>();
+    ArrayList<View> f = new ArrayList<>();
+    private ArrayList<String> g = null;
+    private ArrayList<Class> h = null;
+    private ArrayList<Integer> i = null;
+    private ArrayList<View> j = null;
+    private ArrayList<Class> k = null;
+    private ArrayList<String> l = null;
+    private ArrayList<Integer> m = null;
+    private ArrayList<View> n = null;
+    private ArrayList<Class> o = null;
+    private TransitionValuesMaps p = new TransitionValuesMaps();
+    private TransitionValuesMaps q = new TransitionValuesMaps();
+    TransitionSet r = null;
+    private int[] s = H;
+    boolean v = false;
+    ArrayList<Animator> x = new ArrayList<>();
+    private int y = 0;
+    private boolean z = false;
+    private boolean A = false;
+    private ArrayList<TransitionListener> B = null;
+    private ArrayList<Animator> C = new ArrayList<>();
+    private PathMotion G = I;
+
+    private static class AnimationInfo {
+        View a;
+        String b;
+        TransitionValues c;
+        WindowIdImpl d;
+        Transition e;
+
+        AnimationInfo(View view, String str, Transition transition, WindowIdImpl windowIdImpl, TransitionValues transitionValues) {
+            this.a = view;
+            this.b = str;
+            this.c = transitionValues;
+            this.d = windowIdImpl;
+            this.e = transition;
+        }
+    }
+
+    public static abstract class EpicenterCallback {
+    }
+
+    public interface TransitionListener {
+        void a(Transition transition);
+
+        void b(Transition transition);
+
+        void c(Transition transition);
+
+        void d(Transition transition);
+    }
+
+    private void c(View view, boolean z) {
+        if (view == null) {
+            return;
+        }
+        int id = view.getId();
+        ArrayList<Integer> arrayList = this.i;
+        if (arrayList == null || !arrayList.contains(Integer.valueOf(id))) {
+            ArrayList<View> arrayList2 = this.j;
+            if (arrayList2 == null || !arrayList2.contains(view)) {
+                ArrayList<Class> arrayList3 = this.k;
+                if (arrayList3 != null) {
+                    int size = arrayList3.size();
+                    for (int i = 0; i < size; i++) {
+                        if (this.k.get(i).isInstance(view)) {
+                            return;
+                        }
+                    }
+                }
+                if (view.getParent() instanceof ViewGroup) {
+                    TransitionValues transitionValues = new TransitionValues();
+                    transitionValues.b = view;
+                    if (z) {
+                        c(transitionValues);
+                    } else {
+                        a(transitionValues);
+                    }
+                    transitionValues.c.add(this);
+                    b(transitionValues);
+                    if (z) {
+                        a(this.p, view, transitionValues);
+                    } else {
+                        a(this.q, view, transitionValues);
+                    }
+                }
+                if (view instanceof ViewGroup) {
+                    ArrayList<Integer> arrayList4 = this.m;
+                    if (arrayList4 == null || !arrayList4.contains(Integer.valueOf(id))) {
+                        ArrayList<View> arrayList5 = this.n;
+                        if (arrayList5 == null || !arrayList5.contains(view)) {
+                            ArrayList<Class> arrayList6 = this.o;
+                            if (arrayList6 != null) {
+                                int size2 = arrayList6.size();
+                                for (int i2 = 0; i2 < size2; i2++) {
+                                    if (this.o.get(i2).isInstance(view)) {
+                                        return;
+                                    }
+                                }
+                            }
+                            ViewGroup viewGroup = (ViewGroup) view;
+                            for (int i3 = 0; i3 < viewGroup.getChildCount(); i3++) {
+                                c(viewGroup.getChildAt(i3), z);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static ArrayMap<Animator, AnimationInfo> u() {
+        ArrayMap<Animator, AnimationInfo> arrayMap = J.get();
+        if (arrayMap != null) {
+            return arrayMap;
+        }
+        ArrayMap<Animator, AnimationInfo> arrayMap2 = new ArrayMap<>();
+        J.set(arrayMap2);
+        return arrayMap2;
+    }
+
+    public Animator a(ViewGroup viewGroup, TransitionValues transitionValues, TransitionValues transitionValues2) {
+        return null;
+    }
+
+    public Transition a(long j) {
+        this.c = j;
+        return this;
+    }
+
+    public abstract void a(TransitionValues transitionValues);
+
+    public long b() {
+        return this.c;
+    }
+
+    public abstract void c(TransitionValues transitionValues);
+
+    public Transition d(View view) {
+        this.f.remove(view);
+        return this;
+    }
+
+    public void e(View view) {
+        if (this.z) {
+            if (!this.A) {
+                ArrayMap<Animator, AnimationInfo> u = u();
+                int size = u.size();
+                WindowIdImpl d = ViewUtils.d(view);
+                for (int i = size - 1; i >= 0; i--) {
+                    AnimationInfo d2 = u.d(i);
+                    if (d2.a != null && d.equals(d2.d)) {
+                        AnimatorUtils.b(u.b(i));
+                    }
+                }
+                ArrayList<TransitionListener> arrayList = this.B;
+                if (arrayList != null && arrayList.size() > 0) {
+                    ArrayList arrayList2 = (ArrayList) this.B.clone();
+                    int size2 = arrayList2.size();
+                    for (int i2 = 0; i2 < size2; i2++) {
+                        ((TransitionListener) arrayList2.get(i2)).d(this);
+                    }
+                }
+            }
+            this.z = false;
+        }
+    }
+
+    public EpicenterCallback h() {
+        return this.E;
+    }
+
+    public TimeInterpolator i() {
+        return this.d;
+    }
+
+    public String j() {
+        return this.a;
+    }
+
+    public PathMotion k() {
+        return this.G;
+    }
+
+    public TransitionPropagation l() {
+        return this.D;
+    }
+
+    public long m() {
+        return this.b;
+    }
+
+    public List<Integer> n() {
+        return this.e;
+    }
+
+    public List<String> o() {
+        return this.g;
+    }
+
+    public List<Class> p() {
+        return this.h;
+    }
+
+    public List<View> q() {
+        return this.f;
+    }
+
+    public String[] r() {
+        return null;
+    }
+
+    protected void s() {
+        t();
+        ArrayMap<Animator, AnimationInfo> u = u();
+        Iterator<Animator> it = this.C.iterator();
+        while (it.hasNext()) {
+            Animator next = it.next();
+            if (u.containsKey(next)) {
+                t();
+                a(next, u);
+            }
+        }
+        this.C.clear();
+        a();
+    }
+
+    protected void t() {
+        if (this.y == 0) {
+            ArrayList<TransitionListener> arrayList = this.B;
+            if (arrayList != null && arrayList.size() > 0) {
+                ArrayList arrayList2 = (ArrayList) this.B.clone();
+                int size = arrayList2.size();
+                for (int i = 0; i < size; i++) {
+                    ((TransitionListener) arrayList2.get(i)).a(this);
+                }
+            }
+            this.A = false;
+        }
+        this.y++;
+    }
+
+    public String toString() {
+        return a("");
+    }
+
+    public Transition a(TimeInterpolator timeInterpolator) {
+        this.d = timeInterpolator;
+        return this;
+    }
+
+    public Transition b(long j) {
+        this.b = j;
+        return this;
+    }
+
+    @Override // 
+    /* renamed from: clone, reason: merged with bridge method [inline-methods] */
+    public Transition mo3clone() {
+        try {
+            Transition transition = (Transition) super.clone();
+            transition.C = new ArrayList<>();
+            transition.p = new TransitionValuesMaps();
+            transition.q = new TransitionValuesMaps();
+            transition.t = null;
+            transition.u = null;
+            return transition;
+        } catch (CloneNotSupportedException unused) {
+            return null;
+        }
+    }
+
+    private void a(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2, LongSparseArray<View> longSparseArray, LongSparseArray<View> longSparseArray2) {
+        View b;
+        int b2 = longSparseArray.b();
+        for (int i = 0; i < b2; i++) {
+            View c = longSparseArray.c(i);
+            if (c != null && b(c) && (b = longSparseArray2.b(longSparseArray.a(i))) != null && b(b)) {
+                TransitionValues transitionValues = arrayMap.get(c);
+                TransitionValues transitionValues2 = arrayMap2.get(b);
+                if (transitionValues != null && transitionValues2 != null) {
+                    this.t.add(transitionValues);
+                    this.u.add(transitionValues2);
+                    arrayMap.remove(c);
+                    arrayMap2.remove(b);
+                }
+            }
+        }
+    }
+
+    private void b(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2) {
+        TransitionValues remove;
+        View view;
+        for (int size = arrayMap.size() - 1; size >= 0; size--) {
+            View b = arrayMap.b(size);
+            if (b != null && b(b) && (remove = arrayMap2.remove(b)) != null && (view = remove.b) != null && b(view)) {
+                this.t.add(arrayMap.c(size));
+                this.u.add(remove);
+            }
+        }
+    }
+
+    boolean b(View view) {
+        ArrayList<Class> arrayList;
+        ArrayList<String> arrayList2;
+        int id = view.getId();
+        ArrayList<Integer> arrayList3 = this.i;
+        if (arrayList3 != null && arrayList3.contains(Integer.valueOf(id))) {
+            return false;
+        }
+        ArrayList<View> arrayList4 = this.j;
+        if (arrayList4 != null && arrayList4.contains(view)) {
+            return false;
+        }
+        ArrayList<Class> arrayList5 = this.k;
+        if (arrayList5 != null) {
+            int size = arrayList5.size();
+            for (int i = 0; i < size; i++) {
+                if (this.k.get(i).isInstance(view)) {
+                    return false;
+                }
+            }
+        }
+        if (this.l != null && ViewCompat.p(view) != null && this.l.contains(ViewCompat.p(view))) {
+            return false;
+        }
+        if ((this.e.size() == 0 && this.f.size() == 0 && (((arrayList = this.h) == null || arrayList.isEmpty()) && ((arrayList2 = this.g) == null || arrayList2.isEmpty()))) || this.e.contains(Integer.valueOf(id)) || this.f.contains(view)) {
+            return true;
+        }
+        ArrayList<String> arrayList6 = this.g;
+        if (arrayList6 != null && arrayList6.contains(ViewCompat.p(view))) {
+            return true;
+        }
+        if (this.h != null) {
+            for (int i2 = 0; i2 < this.h.size(); i2++) {
+                if (this.h.get(i2).isInstance(view)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private void a(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2, SparseArray<View> sparseArray, SparseArray<View> sparseArray2) {
+        View view;
+        int size = sparseArray.size();
+        for (int i = 0; i < size; i++) {
+            View valueAt = sparseArray.valueAt(i);
+            if (valueAt != null && b(valueAt) && (view = sparseArray2.get(sparseArray.keyAt(i))) != null && b(view)) {
+                TransitionValues transitionValues = arrayMap.get(valueAt);
+                TransitionValues transitionValues2 = arrayMap2.get(view);
+                if (transitionValues != null && transitionValues2 != null) {
+                    this.t.add(transitionValues);
+                    this.u.add(transitionValues2);
+                    arrayMap.remove(valueAt);
+                    arrayMap2.remove(view);
+                }
+            }
+        }
+    }
+
+    private void a(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2, ArrayMap<String, View> arrayMap3, ArrayMap<String, View> arrayMap4) {
+        View view;
+        int size = arrayMap3.size();
+        for (int i = 0; i < size; i++) {
+            View d = arrayMap3.d(i);
+            if (d != null && b(d) && (view = arrayMap4.get(arrayMap3.b(i))) != null && b(view)) {
+                TransitionValues transitionValues = arrayMap.get(d);
+                TransitionValues transitionValues2 = arrayMap2.get(view);
+                if (transitionValues != null && transitionValues2 != null) {
+                    this.t.add(transitionValues);
+                    this.u.add(transitionValues2);
+                    arrayMap.remove(d);
+                    arrayMap2.remove(view);
+                }
+            }
+        }
+    }
+
+    public void c(View view) {
+        if (this.A) {
+            return;
+        }
+        ArrayMap<Animator, AnimationInfo> u = u();
+        int size = u.size();
+        WindowIdImpl d = ViewUtils.d(view);
+        for (int i = size - 1; i >= 0; i--) {
+            AnimationInfo d2 = u.d(i);
+            if (d2.a != null && d.equals(d2.d)) {
+                AnimatorUtils.a(u.b(i));
+            }
+        }
+        ArrayList<TransitionListener> arrayList = this.B;
+        if (arrayList != null && arrayList.size() > 0) {
+            ArrayList arrayList2 = (ArrayList) this.B.clone();
+            int size2 = arrayList2.size();
+            for (int i2 = 0; i2 < size2; i2++) {
+                ((TransitionListener) arrayList2.get(i2)).b(this);
+            }
+        }
+        this.z = true;
+    }
+
+    public TransitionValues b(View view, boolean z) {
+        TransitionSet transitionSet = this.r;
+        if (transitionSet != null) {
+            return transitionSet.b(view, z);
+        }
+        return (z ? this.p : this.q).a.get(view);
+    }
+
+    public Transition b(TransitionListener transitionListener) {
+        ArrayList<TransitionListener> arrayList = this.B;
+        if (arrayList == null) {
+            return this;
+        }
+        arrayList.remove(transitionListener);
+        if (this.B.size() == 0) {
+            this.B = null;
+        }
+        return this;
+    }
+
+    private void a(ArrayMap<View, TransitionValues> arrayMap, ArrayMap<View, TransitionValues> arrayMap2) {
+        for (int i = 0; i < arrayMap.size(); i++) {
+            TransitionValues d = arrayMap.d(i);
+            if (b(d.b)) {
+                this.t.add(d);
+                this.u.add(null);
+            }
+        }
+        for (int i2 = 0; i2 < arrayMap2.size(); i2++) {
+            TransitionValues d2 = arrayMap2.d(i2);
+            if (b(d2.b)) {
+                this.u.add(d2);
+                this.t.add(null);
+            }
+        }
+    }
+
+    void b(TransitionValues transitionValues) {
+        String[] a;
+        if (this.D == null || transitionValues.a.isEmpty() || (a = this.D.a()) == null) {
+            return;
+        }
+        boolean z = false;
+        int i = 0;
+        while (true) {
+            if (i >= a.length) {
+                z = true;
+                break;
+            } else if (!transitionValues.a.containsKey(a[i])) {
+                break;
+            } else {
+                i++;
+            }
+        }
+        if (z) {
+            return;
+        }
+        this.D.a(transitionValues);
+    }
+
+    private void a(TransitionValuesMaps transitionValuesMaps, TransitionValuesMaps transitionValuesMaps2) {
+        ArrayMap<View, TransitionValues> arrayMap = new ArrayMap<>(transitionValuesMaps.a);
+        ArrayMap<View, TransitionValues> arrayMap2 = new ArrayMap<>(transitionValuesMaps2.a);
+        int i = 0;
+        while (true) {
+            int[] iArr = this.s;
+            if (i < iArr.length) {
+                int i2 = iArr[i];
+                if (i2 == 1) {
+                    b(arrayMap, arrayMap2);
+                } else if (i2 == 2) {
+                    a(arrayMap, arrayMap2, transitionValuesMaps.d, transitionValuesMaps2.d);
+                } else if (i2 == 3) {
+                    a(arrayMap, arrayMap2, transitionValuesMaps.b, transitionValuesMaps2.b);
+                } else if (i2 == 4) {
+                    a(arrayMap, arrayMap2, transitionValuesMaps.c, transitionValuesMaps2.c);
+                }
+                i++;
+            } else {
+                a(arrayMap, arrayMap2);
+                return;
+            }
+        }
+    }
+
+    protected void a(ViewGroup viewGroup, TransitionValuesMaps transitionValuesMaps, TransitionValuesMaps transitionValuesMaps2, ArrayList<TransitionValues> arrayList, ArrayList<TransitionValues> arrayList2) {
+        Animator a;
+        int i;
+        int i2;
+        View view;
+        Animator animator;
+        TransitionValues transitionValues;
+        Animator animator2;
+        TransitionValues transitionValues2;
+        ArrayMap<Animator, AnimationInfo> u = u();
+        SparseIntArray sparseIntArray = new SparseIntArray();
+        int size = arrayList.size();
+        long j = Long.MAX_VALUE;
+        int i3 = 0;
+        while (i3 < size) {
+            TransitionValues transitionValues3 = arrayList.get(i3);
+            TransitionValues transitionValues4 = arrayList2.get(i3);
+            if (transitionValues3 != null && !transitionValues3.c.contains(this)) {
+                transitionValues3 = null;
+            }
+            if (transitionValues4 != null && !transitionValues4.c.contains(this)) {
+                transitionValues4 = null;
+            }
+            if (transitionValues3 != null || transitionValues4 != null) {
+                if ((transitionValues3 == null || transitionValues4 == null || a(transitionValues3, transitionValues4)) && (a = a(viewGroup, transitionValues3, transitionValues4)) != null) {
+                    if (transitionValues4 != null) {
+                        view = transitionValues4.b;
+                        String[] r = r();
+                        if (view == null || r == null || r.length <= 0) {
+                            i = size;
+                            i2 = i3;
+                            animator2 = a;
+                            transitionValues2 = null;
+                        } else {
+                            transitionValues2 = new TransitionValues();
+                            transitionValues2.b = view;
+                            i = size;
+                            TransitionValues transitionValues5 = transitionValuesMaps2.a.get(view);
+                            if (transitionValues5 != null) {
+                                int i4 = 0;
+                                while (i4 < r.length) {
+                                    transitionValues2.a.put(r[i4], transitionValues5.a.get(r[i4]));
+                                    i4++;
+                                    i3 = i3;
+                                    transitionValues5 = transitionValues5;
+                                }
+                            }
+                            i2 = i3;
+                            int size2 = u.size();
+                            int i5 = 0;
+                            while (true) {
+                                if (i5 >= size2) {
+                                    animator2 = a;
+                                    break;
+                                }
+                                AnimationInfo animationInfo = u.get(u.b(i5));
+                                if (animationInfo.c != null && animationInfo.a == view && animationInfo.b.equals(j()) && animationInfo.c.equals(transitionValues2)) {
+                                    animator2 = null;
+                                    break;
+                                }
+                                i5++;
+                            }
+                        }
+                        animator = animator2;
+                        transitionValues = transitionValues2;
+                    } else {
+                        i = size;
+                        i2 = i3;
+                        view = transitionValues3.b;
+                        animator = a;
+                        transitionValues = null;
+                    }
+                    if (animator != null) {
+                        TransitionPropagation transitionPropagation = this.D;
+                        if (transitionPropagation != null) {
+                            long a2 = transitionPropagation.a(viewGroup, this, transitionValues3, transitionValues4);
+                            sparseIntArray.put(this.C.size(), (int) a2);
+                            j = Math.min(a2, j);
+                        }
+                        u.put(animator, new AnimationInfo(view, j(), this, ViewUtils.d(viewGroup), transitionValues));
+                        this.C.add(animator);
+                        j = j;
+                    }
+                    i3 = i2 + 1;
+                    size = i;
+                }
+            }
+            i = size;
+            i2 = i3;
+            i3 = i2 + 1;
+            size = i;
+        }
+        if (j != 0) {
+            for (int i6 = 0; i6 < sparseIntArray.size(); i6++) {
+                Animator animator3 = this.C.get(sparseIntArray.keyAt(i6));
+                animator3.setStartDelay((sparseIntArray.valueAt(i6) - j) + animator3.getStartDelay());
+            }
+        }
+    }
+
+    private void a(Animator animator, final ArrayMap<Animator, AnimationInfo> arrayMap) {
+        if (animator != null) {
+            animator.addListener(new AnimatorListenerAdapter() { // from class: androidx.transition.Transition.2
+                @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                public void onAnimationEnd(Animator animator2) {
+                    arrayMap.remove(animator2);
+                    Transition.this.x.remove(animator2);
+                }
+
+                @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+                public void onAnimationStart(Animator animator2) {
+                    Transition.this.x.add(animator2);
+                }
+            });
+            a(animator);
+        }
+    }
+
+    public Transition a(View view) {
+        this.f.add(view);
+        return this;
+    }
+
+    void a(ViewGroup viewGroup, boolean z) {
+        ArrayList<String> arrayList;
+        ArrayList<Class> arrayList2;
+        ArrayMap<String, String> arrayMap;
+        a(z);
+        if ((this.e.size() <= 0 && this.f.size() <= 0) || (((arrayList = this.g) != null && !arrayList.isEmpty()) || ((arrayList2 = this.h) != null && !arrayList2.isEmpty()))) {
+            c(viewGroup, z);
+        } else {
+            for (int i = 0; i < this.e.size(); i++) {
+                View findViewById = viewGroup.findViewById(this.e.get(i).intValue());
+                if (findViewById != null) {
+                    TransitionValues transitionValues = new TransitionValues();
+                    transitionValues.b = findViewById;
+                    if (z) {
+                        c(transitionValues);
+                    } else {
+                        a(transitionValues);
+                    }
+                    transitionValues.c.add(this);
+                    b(transitionValues);
+                    if (z) {
+                        a(this.p, findViewById, transitionValues);
+                    } else {
+                        a(this.q, findViewById, transitionValues);
+                    }
+                }
+            }
+            for (int i2 = 0; i2 < this.f.size(); i2++) {
+                View view = this.f.get(i2);
+                TransitionValues transitionValues2 = new TransitionValues();
+                transitionValues2.b = view;
+                if (z) {
+                    c(transitionValues2);
+                } else {
+                    a(transitionValues2);
+                }
+                transitionValues2.c.add(this);
+                b(transitionValues2);
+                if (z) {
+                    a(this.p, view, transitionValues2);
+                } else {
+                    a(this.q, view, transitionValues2);
+                }
+            }
+        }
+        if (z || (arrayMap = this.F) == null) {
+            return;
+        }
+        int size = arrayMap.size();
+        ArrayList arrayList3 = new ArrayList(size);
+        for (int i3 = 0; i3 < size; i3++) {
+            arrayList3.add(this.p.d.remove(this.F.b(i3)));
+        }
+        for (int i4 = 0; i4 < size; i4++) {
+            View view2 = (View) arrayList3.get(i4);
+            if (view2 != null) {
+                this.p.d.put(this.F.d(i4), view2);
+            }
+        }
+    }
+
+    private static void a(TransitionValuesMaps transitionValuesMaps, View view, TransitionValues transitionValues) {
+        transitionValuesMaps.a.put(view, transitionValues);
+        int id = view.getId();
+        if (id >= 0) {
+            if (transitionValuesMaps.b.indexOfKey(id) >= 0) {
+                transitionValuesMaps.b.put(id, null);
+            } else {
+                transitionValuesMaps.b.put(id, view);
+            }
+        }
+        String p = ViewCompat.p(view);
+        if (p != null) {
+            if (transitionValuesMaps.d.containsKey(p)) {
+                transitionValuesMaps.d.put(p, null);
+            } else {
+                transitionValuesMaps.d.put(p, view);
+            }
+        }
+        if (view.getParent() instanceof ListView) {
+            ListView listView = (ListView) view.getParent();
+            if (listView.getAdapter().hasStableIds()) {
+                long itemIdAtPosition = listView.getItemIdAtPosition(listView.getPositionForView(view));
+                if (transitionValuesMaps.c.c(itemIdAtPosition) >= 0) {
+                    View b = transitionValuesMaps.c.b(itemIdAtPosition);
+                    if (b != null) {
+                        ViewCompat.b(b, false);
+                        transitionValuesMaps.c.c(itemIdAtPosition, null);
+                        return;
+                    }
+                    return;
+                }
+                ViewCompat.b(view, true);
+                transitionValuesMaps.c.c(itemIdAtPosition, view);
+            }
+        }
+    }
+
+    void a(boolean z) {
+        if (z) {
+            this.p.a.clear();
+            this.p.b.clear();
+            this.p.c.a();
+        } else {
+            this.q.a.clear();
+            this.q.b.clear();
+            this.q.c.a();
+        }
+    }
+
+    TransitionValues a(View view, boolean z) {
+        TransitionSet transitionSet = this.r;
+        if (transitionSet != null) {
+            return transitionSet.a(view, z);
+        }
+        ArrayList<TransitionValues> arrayList = z ? this.t : this.u;
+        if (arrayList == null) {
+            return null;
+        }
+        int size = arrayList.size();
+        int i = -1;
+        int i2 = 0;
+        while (true) {
+            if (i2 >= size) {
+                break;
+            }
+            TransitionValues transitionValues = arrayList.get(i2);
+            if (transitionValues == null) {
+                return null;
+            }
+            if (transitionValues.b == view) {
+                i = i2;
+                break;
+            }
+            i2++;
+        }
+        if (i >= 0) {
+            return (z ? this.u : this.t).get(i);
+        }
+        return null;
+    }
+
+    void a(ViewGroup viewGroup) {
+        AnimationInfo animationInfo;
+        this.t = new ArrayList<>();
+        this.u = new ArrayList<>();
+        a(this.p, this.q);
+        ArrayMap<Animator, AnimationInfo> u = u();
+        int size = u.size();
+        WindowIdImpl d = ViewUtils.d(viewGroup);
+        for (int i = size - 1; i >= 0; i--) {
+            Animator b = u.b(i);
+            if (b != null && (animationInfo = u.get(b)) != null && animationInfo.a != null && d.equals(animationInfo.d)) {
+                TransitionValues transitionValues = animationInfo.c;
+                View view = animationInfo.a;
+                TransitionValues b2 = b(view, true);
+                TransitionValues a = a(view, true);
+                if (!(b2 == null && a == null) && animationInfo.e.a(transitionValues, a)) {
+                    if (!b.isRunning() && !b.isStarted()) {
+                        u.remove(b);
+                    } else {
+                        b.cancel();
+                    }
+                }
+            }
+        }
+        a(viewGroup, this.p, this.q, this.t, this.u);
+        s();
+    }
+
+    public boolean a(TransitionValues transitionValues, TransitionValues transitionValues2) {
+        if (transitionValues == null || transitionValues2 == null) {
+            return false;
+        }
+        String[] r = r();
+        if (r != null) {
+            for (String str : r) {
+                if (!a(transitionValues, transitionValues2, str)) {
+                }
+            }
+            return false;
+        }
+        Iterator<String> it = transitionValues.a.keySet().iterator();
+        while (it.hasNext()) {
+            if (a(transitionValues, transitionValues2, it.next())) {
+            }
+        }
+        return false;
+        return true;
+    }
+
+    private static boolean a(TransitionValues transitionValues, TransitionValues transitionValues2, String str) {
+        Object obj = transitionValues.a.get(str);
+        Object obj2 = transitionValues2.a.get(str);
+        if (obj == null && obj2 == null) {
+            return false;
+        }
+        if (obj == null || obj2 == null) {
+            return true;
+        }
+        return true ^ obj.equals(obj2);
+    }
+
+    protected void a(Animator animator) {
+        if (animator == null) {
+            a();
+            return;
+        }
+        if (b() >= 0) {
+            animator.setDuration(b());
+        }
+        if (m() >= 0) {
+            animator.setStartDelay(m());
+        }
+        if (i() != null) {
+            animator.setInterpolator(i());
+        }
+        animator.addListener(new AnimatorListenerAdapter() { // from class: androidx.transition.Transition.3
+            @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+            public void onAnimationEnd(Animator animator2) {
+                Transition.this.a();
+                animator2.removeListener(this);
+            }
+        });
+        animator.start();
+    }
+
+    protected void a() {
+        this.y--;
+        if (this.y == 0) {
+            ArrayList<TransitionListener> arrayList = this.B;
+            if (arrayList != null && arrayList.size() > 0) {
+                ArrayList arrayList2 = (ArrayList) this.B.clone();
+                int size = arrayList2.size();
+                for (int i = 0; i < size; i++) {
+                    ((TransitionListener) arrayList2.get(i)).c(this);
+                }
+            }
+            for (int i2 = 0; i2 < this.p.c.b(); i2++) {
+                View c = this.p.c.c(i2);
+                if (c != null) {
+                    ViewCompat.b(c, false);
+                }
+            }
+            for (int i3 = 0; i3 < this.q.c.b(); i3++) {
+                View c2 = this.q.c.c(i3);
+                if (c2 != null) {
+                    ViewCompat.b(c2, false);
+                }
+            }
+            this.A = true;
+        }
+    }
+
+    public Transition a(TransitionListener transitionListener) {
+        if (this.B == null) {
+            this.B = new ArrayList<>();
+        }
+        this.B.add(transitionListener);
+        return this;
+    }
+
+    public void a(PathMotion pathMotion) {
+        if (pathMotion == null) {
+            this.G = I;
+        } else {
+            this.G = pathMotion;
+        }
+    }
+
+    public void a(EpicenterCallback epicenterCallback) {
+        this.E = epicenterCallback;
+    }
+
+    public void a(TransitionPropagation transitionPropagation) {
+        this.D = transitionPropagation;
+    }
+
+    String a(String str) {
+        String str2 = str + getClass().getSimpleName() + "@" + Integer.toHexString(hashCode()) + ": ";
+        if (this.c != -1) {
+            str2 = str2 + "dur(" + this.c + ") ";
+        }
+        if (this.b != -1) {
+            str2 = str2 + "dly(" + this.b + ") ";
+        }
+        if (this.d != null) {
+            str2 = str2 + "interp(" + this.d + ") ";
+        }
+        if (this.e.size() <= 0 && this.f.size() <= 0) {
+            return str2;
+        }
+        String str3 = str2 + "tgts(";
+        if (this.e.size() > 0) {
+            String str4 = str3;
+            for (int i = 0; i < this.e.size(); i++) {
+                if (i > 0) {
+                    str4 = str4 + ", ";
+                }
+                str4 = str4 + this.e.get(i);
+            }
+            str3 = str4;
+        }
+        if (this.f.size() > 0) {
+            for (int i2 = 0; i2 < this.f.size(); i2++) {
+                if (i2 > 0) {
+                    str3 = str3 + ", ";
+                }
+                str3 = str3 + this.f.get(i2);
+            }
+        }
+        return str3 + ")";
+    }
+}

sources/androidx/transition/TransitionListenerAdapter.java

@@ -0,0 +1,18 @@
+package androidx.transition;
+
+import androidx.transition.Transition;
+
+/* loaded from: classes.dex */
+public class TransitionListenerAdapter implements Transition.TransitionListener {
+    @Override // androidx.transition.Transition.TransitionListener
+    public void a(Transition transition) {
+    }
+
+    @Override // androidx.transition.Transition.TransitionListener
+    public void b(Transition transition) {
+    }
+
+    @Override // androidx.transition.Transition.TransitionListener
+    public void d(Transition transition) {
+    }
+}

sources/androidx/transition/TransitionManager.java

@@ -0,0 +1,135 @@
+package androidx.transition;
+
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import androidx.collection.ArrayMap;
+import androidx.core.view.ViewCompat;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class TransitionManager {
+    private static Transition a = new AutoTransition();
+    private static ThreadLocal<WeakReference<ArrayMap<ViewGroup, ArrayList<Transition>>>> b = new ThreadLocal<>();
+    static ArrayList<ViewGroup> c = new ArrayList<>();
+
+    private static class MultiListener implements ViewTreeObserver.OnPreDrawListener, View.OnAttachStateChangeListener {
+        Transition a;
+        ViewGroup b;
+
+        MultiListener(Transition transition, ViewGroup viewGroup) {
+            this.a = transition;
+            this.b = viewGroup;
+        }
+
+        private void a() {
+            this.b.getViewTreeObserver().removeOnPreDrawListener(this);
+            this.b.removeOnAttachStateChangeListener(this);
+        }
+
+        @Override // android.view.ViewTreeObserver.OnPreDrawListener
+        public boolean onPreDraw() {
+            a();
+            if (!TransitionManager.c.remove(this.b)) {
+                return true;
+            }
+            final ArrayMap<ViewGroup, ArrayList<Transition>> a = TransitionManager.a();
+            ArrayList<Transition> arrayList = a.get(this.b);
+            ArrayList arrayList2 = null;
+            if (arrayList == null) {
+                arrayList = new ArrayList<>();
+                a.put(this.b, arrayList);
+            } else if (arrayList.size() > 0) {
+                arrayList2 = new ArrayList(arrayList);
+            }
+            arrayList.add(this.a);
+            this.a.a(new TransitionListenerAdapter() { // from class: androidx.transition.TransitionManager.MultiListener.1
+                /* JADX WARN: Multi-variable type inference failed */
+                @Override // androidx.transition.Transition.TransitionListener
+                public void c(Transition transition) {
+                    ((ArrayList) a.get(MultiListener.this.b)).remove(transition);
+                }
+            });
+            this.a.a(this.b, false);
+            if (arrayList2 != null) {
+                Iterator it = arrayList2.iterator();
+                while (it.hasNext()) {
+                    ((Transition) it.next()).e(this.b);
+                }
+            }
+            this.a.a(this.b);
+            return true;
+        }
+
+        @Override // android.view.View.OnAttachStateChangeListener
+        public void onViewAttachedToWindow(View view) {
+        }
+
+        @Override // android.view.View.OnAttachStateChangeListener
+        public void onViewDetachedFromWindow(View view) {
+            a();
+            TransitionManager.c.remove(this.b);
+            ArrayList<Transition> arrayList = TransitionManager.a().get(this.b);
+            if (arrayList != null && arrayList.size() > 0) {
+                Iterator<Transition> it = arrayList.iterator();
+                while (it.hasNext()) {
+                    it.next().e(this.b);
+                }
+            }
+            this.a.a(true);
+        }
+    }
+
+    static ArrayMap<ViewGroup, ArrayList<Transition>> a() {
+        ArrayMap<ViewGroup, ArrayList<Transition>> arrayMap;
+        WeakReference<ArrayMap<ViewGroup, ArrayList<Transition>>> weakReference = b.get();
+        if (weakReference != null && (arrayMap = weakReference.get()) != null) {
+            return arrayMap;
+        }
+        ArrayMap<ViewGroup, ArrayList<Transition>> arrayMap2 = new ArrayMap<>();
+        b.set(new WeakReference<>(arrayMap2));
+        return arrayMap2;
+    }
+
+    private static void b(ViewGroup viewGroup, Transition transition) {
+        if (transition == null || viewGroup == null) {
+            return;
+        }
+        MultiListener multiListener = new MultiListener(transition, viewGroup);
+        viewGroup.addOnAttachStateChangeListener(multiListener);
+        viewGroup.getViewTreeObserver().addOnPreDrawListener(multiListener);
+    }
+
+    private static void c(ViewGroup viewGroup, Transition transition) {
+        ArrayList<Transition> arrayList = a().get(viewGroup);
+        if (arrayList != null && arrayList.size() > 0) {
+            Iterator<Transition> it = arrayList.iterator();
+            while (it.hasNext()) {
+                it.next().c(viewGroup);
+            }
+        }
+        if (transition != null) {
+            transition.a(viewGroup, true);
+        }
+        Scene a2 = Scene.a(viewGroup);
+        if (a2 != null) {
+            a2.a();
+        }
+    }
+
+    public static void a(ViewGroup viewGroup, Transition transition) {
+        if (c.contains(viewGroup) || !ViewCompat.x(viewGroup)) {
+            return;
+        }
+        c.add(viewGroup);
+        if (transition == null) {
+            transition = a;
+        }
+        Transition mo3clone = transition.mo3clone();
+        c(viewGroup, mo3clone);
+        Scene.a(viewGroup, null);
+        b(viewGroup, mo3clone);
+    }
+}

sources/androidx/transition/TransitionPropagation.java

@@ -0,0 +1,12 @@
+package androidx.transition;
+
+import android.view.ViewGroup;
+
+/* loaded from: classes.dex */
+public abstract class TransitionPropagation {
+    public abstract long a(ViewGroup viewGroup, Transition transition, TransitionValues transitionValues, TransitionValues transitionValues2);
+
+    public abstract void a(TransitionValues transitionValues);
+
+    public abstract String[] a();
+}

sources/androidx/transition/TransitionSet.java

@@ -0,0 +1,327 @@
+package androidx.transition;
+
+import android.animation.TimeInterpolator;
+import android.util.AndroidRuntimeException;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.transition.Transition;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/* loaded from: classes.dex */
+public class TransitionSet extends Transition {
+    int M;
+    private ArrayList<Transition> K = new ArrayList<>();
+    private boolean L = true;
+    boolean N = false;
+    private int O = 0;
+
+    static class TransitionSetListener extends TransitionListenerAdapter {
+        TransitionSet a;
+
+        TransitionSetListener(TransitionSet transitionSet) {
+            this.a = transitionSet;
+        }
+
+        @Override // androidx.transition.TransitionListenerAdapter, androidx.transition.Transition.TransitionListener
+        public void a(Transition transition) {
+            TransitionSet transitionSet = this.a;
+            if (transitionSet.N) {
+                return;
+            }
+            transitionSet.t();
+            this.a.N = true;
+        }
+
+        @Override // androidx.transition.Transition.TransitionListener
+        public void c(Transition transition) {
+            TransitionSet transitionSet = this.a;
+            transitionSet.M--;
+            if (transitionSet.M == 0) {
+                transitionSet.N = false;
+                transitionSet.a();
+            }
+            transition.b(this);
+        }
+    }
+
+    private void v() {
+        TransitionSetListener transitionSetListener = new TransitionSetListener(this);
+        Iterator<Transition> it = this.K.iterator();
+        while (it.hasNext()) {
+            it.next().a(transitionSetListener);
+        }
+        this.M = this.K.size();
+    }
+
+    @Override // androidx.transition.Transition
+    public void c(TransitionValues transitionValues) {
+        if (b(transitionValues.b)) {
+            Iterator<Transition> it = this.K.iterator();
+            while (it.hasNext()) {
+                Transition next = it.next();
+                if (next.b(transitionValues.b)) {
+                    next.c(transitionValues);
+                    transitionValues.c.add(next);
+                }
+            }
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public void e(View view) {
+        super.e(view);
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            this.K.get(i).e(view);
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    protected void s() {
+        if (this.K.isEmpty()) {
+            t();
+            a();
+            return;
+        }
+        v();
+        if (this.L) {
+            Iterator<Transition> it = this.K.iterator();
+            while (it.hasNext()) {
+                it.next().s();
+            }
+            return;
+        }
+        for (int i = 1; i < this.K.size(); i++) {
+            Transition transition = this.K.get(i - 1);
+            final Transition transition2 = this.K.get(i);
+            transition.a(new TransitionListenerAdapter(this) { // from class: androidx.transition.TransitionSet.1
+                @Override // androidx.transition.Transition.TransitionListener
+                public void c(Transition transition3) {
+                    transition2.s();
+                    transition3.b(this);
+                }
+            });
+        }
+        Transition transition3 = this.K.get(0);
+        if (transition3 != null) {
+            transition3.s();
+        }
+    }
+
+    public int u() {
+        return this.K.size();
+    }
+
+    @Override // androidx.transition.Transition
+    /* renamed from: clone */
+    public Transition mo3clone() {
+        TransitionSet transitionSet = (TransitionSet) super.mo3clone();
+        transitionSet.K = new ArrayList<>();
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            transitionSet.a(this.K.get(i).mo3clone());
+        }
+        return transitionSet;
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet d(View view) {
+        for (int i = 0; i < this.K.size(); i++) {
+            this.K.get(i).d(view);
+        }
+        super.d(view);
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public /* bridge */ /* synthetic */ Transition a(long j) {
+        a(j);
+        return this;
+    }
+
+    public TransitionSet b(int i) {
+        if (i == 0) {
+            this.L = true;
+        } else if (i == 1) {
+            this.L = false;
+        } else {
+            throw new AndroidRuntimeException("Invalid parameter for TransitionSet ordering: " + i);
+        }
+        return this;
+    }
+
+    public TransitionSet a(Transition transition) {
+        this.K.add(transition);
+        transition.r = this;
+        long j = this.c;
+        if (j >= 0) {
+            transition.a(j);
+        }
+        if ((this.O & 1) != 0) {
+            transition.a(i());
+        }
+        if ((this.O & 2) != 0) {
+            transition.a(l());
+        }
+        if ((this.O & 4) != 0) {
+            transition.a(k());
+        }
+        if ((this.O & 8) != 0) {
+            transition.a(h());
+        }
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet b(long j) {
+        super.b(j);
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public void c(View view) {
+        super.c(view);
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            this.K.get(i).c(view);
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet b(Transition.TransitionListener transitionListener) {
+        super.b(transitionListener);
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    void b(TransitionValues transitionValues) {
+        super.b(transitionValues);
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            this.K.get(i).b(transitionValues);
+        }
+    }
+
+    public Transition a(int i) {
+        if (i < 0 || i >= this.K.size()) {
+            return null;
+        }
+        return this.K.get(i);
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet a(long j) {
+        super.a(j);
+        if (this.c >= 0) {
+            int size = this.K.size();
+            for (int i = 0; i < size; i++) {
+                this.K.get(i).a(j);
+            }
+        }
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet a(TimeInterpolator timeInterpolator) {
+        this.O |= 1;
+        ArrayList<Transition> arrayList = this.K;
+        if (arrayList != null) {
+            int size = arrayList.size();
+            for (int i = 0; i < size; i++) {
+                this.K.get(i).a(timeInterpolator);
+            }
+        }
+        super.a(timeInterpolator);
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet a(View view) {
+        for (int i = 0; i < this.K.size(); i++) {
+            this.K.get(i).a(view);
+        }
+        super.a(view);
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public TransitionSet a(Transition.TransitionListener transitionListener) {
+        super.a(transitionListener);
+        return this;
+    }
+
+    @Override // androidx.transition.Transition
+    public void a(PathMotion pathMotion) {
+        super.a(pathMotion);
+        this.O |= 4;
+        for (int i = 0; i < this.K.size(); i++) {
+            this.K.get(i).a(pathMotion);
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    protected void a(ViewGroup viewGroup, TransitionValuesMaps transitionValuesMaps, TransitionValuesMaps transitionValuesMaps2, ArrayList<TransitionValues> arrayList, ArrayList<TransitionValues> arrayList2) {
+        long m = m();
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            Transition transition = this.K.get(i);
+            if (m > 0 && (this.L || i == 0)) {
+                long m2 = transition.m();
+                if (m2 > 0) {
+                    transition.b(m2 + m);
+                } else {
+                    transition.b(m);
+                }
+            }
+            transition.a(viewGroup, transitionValuesMaps, transitionValuesMaps2, arrayList, arrayList2);
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public void a(TransitionValues transitionValues) {
+        if (b(transitionValues.b)) {
+            Iterator<Transition> it = this.K.iterator();
+            while (it.hasNext()) {
+                Transition next = it.next();
+                if (next.b(transitionValues.b)) {
+                    next.a(transitionValues);
+                    transitionValues.c.add(next);
+                }
+            }
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public void a(TransitionPropagation transitionPropagation) {
+        super.a(transitionPropagation);
+        this.O |= 2;
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            this.K.get(i).a(transitionPropagation);
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    public void a(Transition.EpicenterCallback epicenterCallback) {
+        super.a(epicenterCallback);
+        this.O |= 8;
+        int size = this.K.size();
+        for (int i = 0; i < size; i++) {
+            this.K.get(i).a(epicenterCallback);
+        }
+    }
+
+    @Override // androidx.transition.Transition
+    String a(String str) {
+        String a = super.a(str);
+        for (int i = 0; i < this.K.size(); i++) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(a);
+            sb.append("\n");
+            sb.append(this.K.get(i).a(str + "  "));
+            a = sb.toString();
+        }
+        return a;
+    }
+}

sources/androidx/transition/TransitionUtils.java

@@ -0,0 +1,154 @@
+package androidx.transition;
+
+import android.animation.Animator;
+import android.animation.AnimatorSet;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.graphics.RectF;
+import android.os.Build;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+/* loaded from: classes.dex */
+class TransitionUtils {
+    private static final boolean a;
+    private static final boolean b;
+    private static final boolean c;
+
+    static {
+        a = Build.VERSION.SDK_INT >= 19;
+        b = Build.VERSION.SDK_INT >= 18;
+        c = Build.VERSION.SDK_INT >= 28;
+    }
+
+    static View a(ViewGroup viewGroup, View view, View view2) {
+        Matrix matrix = new Matrix();
+        matrix.setTranslate(-view2.getScrollX(), -view2.getScrollY());
+        ViewUtils.a(view, matrix);
+        ViewUtils.b(viewGroup, matrix);
+        RectF rectF = new RectF(0.0f, 0.0f, view.getWidth(), view.getHeight());
+        matrix.mapRect(rectF);
+        int round = Math.round(rectF.left);
+        int round2 = Math.round(rectF.top);
+        int round3 = Math.round(rectF.right);
+        int round4 = Math.round(rectF.bottom);
+        ImageView imageView = new ImageView(view.getContext());
+        imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
+        Bitmap a2 = a(view, matrix, rectF, viewGroup);
+        if (a2 != null) {
+            imageView.setImageBitmap(a2);
+        }
+        imageView.measure(View.MeasureSpec.makeMeasureSpec(round3 - round, 1073741824), View.MeasureSpec.makeMeasureSpec(round4 - round2, 1073741824));
+        imageView.layout(round, round2, round3, round4);
+        return imageView;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0073  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x008a  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    private static android.graphics.Bitmap a(android.view.View r9, android.graphics.Matrix r10, android.graphics.RectF r11, android.view.ViewGroup r12) {
+        /*
+            boolean r0 = androidx.transition.TransitionUtils.a
+            r1 = 0
+            if (r0 == 0) goto L13
+            boolean r0 = r9.isAttachedToWindow()
+            r0 = r0 ^ 1
+            if (r12 != 0) goto Le
+            goto L14
+        Le:
+            boolean r2 = r12.isAttachedToWindow()
+            goto L15
+        L13:
+            r0 = 0
+        L14:
+            r2 = 0
+        L15:
+            boolean r3 = androidx.transition.TransitionUtils.b
+            r4 = 0
+            if (r3 == 0) goto L34
+            if (r0 == 0) goto L34
+            if (r2 != 0) goto L1f
+            return r4
+        L1f:
+            android.view.ViewParent r1 = r9.getParent()
+            android.view.ViewGroup r1 = (android.view.ViewGroup) r1
+            int r2 = r1.indexOfChild(r9)
+            android.view.ViewGroupOverlay r3 = r12.getOverlay()
+            r3.add(r9)
+            r8 = r2
+            r2 = r1
+            r1 = r8
+            goto L35
+        L34:
+            r2 = r4
+        L35:
+            float r3 = r11.width()
+            int r3 = java.lang.Math.round(r3)
+            float r5 = r11.height()
+            int r5 = java.lang.Math.round(r5)
+            if (r3 <= 0) goto L9b
+            if (r5 <= 0) goto L9b
+            r4 = 1065353216(0x3f800000, float:1.0)
+            r6 = 1233125376(0x49800000, float:1048576.0)
+            int r7 = r3 * r5
+            float r7 = (float) r7
+            float r6 = r6 / r7
+            float r4 = java.lang.Math.min(r4, r6)
+            float r3 = (float) r3
+            float r3 = r3 * r4
+            int r3 = java.lang.Math.round(r3)
+            float r5 = (float) r5
+            float r5 = r5 * r4
+            int r5 = java.lang.Math.round(r5)
+            float r6 = r11.left
+            float r6 = -r6
+            float r11 = r11.top
+            float r11 = -r11
+            r10.postTranslate(r6, r11)
+            r10.postScale(r4, r4)
+            boolean r11 = androidx.transition.TransitionUtils.c
+            if (r11 == 0) goto L8a
+            android.graphics.Picture r11 = new android.graphics.Picture
+            r11.<init>()
+            android.graphics.Canvas r3 = r11.beginRecording(r3, r5)
+            r3.concat(r10)
+            r9.draw(r3)
+            r11.endRecording()
+            android.graphics.Bitmap r4 = android.graphics.Bitmap.createBitmap(r11)
+            goto L9b
+        L8a:
+            android.graphics.Bitmap$Config r11 = android.graphics.Bitmap.Config.ARGB_8888
+            android.graphics.Bitmap r4 = android.graphics.Bitmap.createBitmap(r3, r5, r11)
+            android.graphics.Canvas r11 = new android.graphics.Canvas
+            r11.<init>(r4)
+            r11.concat(r10)
+            r9.draw(r11)
+        L9b:
+            boolean r10 = androidx.transition.TransitionUtils.b
+            if (r10 == 0) goto Lab
+            if (r0 == 0) goto Lab
+            android.view.ViewGroupOverlay r10 = r12.getOverlay()
+            r10.remove(r9)
+            r2.addView(r9, r1)
+        Lab:
+            return r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.transition.TransitionUtils.a(android.view.View, android.graphics.Matrix, android.graphics.RectF, android.view.ViewGroup):android.graphics.Bitmap");
+    }
+
+    static Animator a(Animator animator, Animator animator2) {
+        if (animator == null) {
+            return animator2;
+        }
+        if (animator2 == null) {
+            return animator;
+        }
+        AnimatorSet animatorSet = new AnimatorSet();
+        animatorSet.playTogether(animator, animator2);
+        return animatorSet;
+    }
+}

sources/androidx/transition/TransitionValues.java

@@ -0,0 +1,33 @@
+package androidx.transition;
+
+import android.view.View;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes.dex */
+public class TransitionValues {
+    public View b;
+    public final Map<String, Object> a = new HashMap();
+    final ArrayList<Transition> c = new ArrayList<>();
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof TransitionValues)) {
+            return false;
+        }
+        TransitionValues transitionValues = (TransitionValues) obj;
+        return this.b == transitionValues.b && this.a.equals(transitionValues.a);
+    }
+
+    public int hashCode() {
+        return (this.b.hashCode() * 31) + this.a.hashCode();
+    }
+
+    public String toString() {
+        String str = (("TransitionValues@" + Integer.toHexString(hashCode()) + ":\n") + "    view = " + this.b + "\n") + "    values:";
+        for (String str2 : this.a.keySet()) {
+            str = str + "    " + str2 + ": " + this.a.get(str2) + "\n";
+        }
+        return str;
+    }
+}

sources/androidx/transition/TransitionValuesMaps.java

@@ -0,0 +1,17 @@
+package androidx.transition;
+
+import android.util.SparseArray;
+import android.view.View;
+import androidx.collection.ArrayMap;
+import androidx.collection.LongSparseArray;
+
+/* loaded from: classes.dex */
+class TransitionValuesMaps {
+    final ArrayMap<View, TransitionValues> a = new ArrayMap<>();
+    final SparseArray<View> b = new SparseArray<>();
+    final LongSparseArray<View> c = new LongSparseArray<>();
+    final ArrayMap<String, View> d = new ArrayMap<>();
+
+    TransitionValuesMaps() {
+    }
+}

sources/androidx/transition/ViewGroupOverlayApi14.java

@@ -0,0 +1,26 @@
+package androidx.transition;
+
+import android.content.Context;
+import android.view.View;
+import android.view.ViewGroup;
+
+/* loaded from: classes.dex */
+class ViewGroupOverlayApi14 extends ViewOverlayApi14 implements ViewGroupOverlayImpl {
+    ViewGroupOverlayApi14(Context context, ViewGroup viewGroup, View view) {
+        super(context, viewGroup, view);
+    }
+
+    static ViewGroupOverlayApi14 a(ViewGroup viewGroup) {
+        return (ViewGroupOverlayApi14) ViewOverlayApi14.c(viewGroup);
+    }
+
+    @Override // androidx.transition.ViewGroupOverlayImpl
+    public void b(View view) {
+        this.a.b(view);
+    }
+
+    @Override // androidx.transition.ViewGroupOverlayImpl
+    public void a(View view) {
+        this.a.a(view);
+    }
+}

sources/androidx/transition/ViewGroupOverlayApi18.java

@@ -0,0 +1,35 @@
+package androidx.transition;
+
+import android.graphics.drawable.Drawable;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewGroupOverlay;
+
+/* loaded from: classes.dex */
+class ViewGroupOverlayApi18 implements ViewGroupOverlayImpl {
+    private final ViewGroupOverlay a;
+
+    ViewGroupOverlayApi18(ViewGroup viewGroup) {
+        this.a = viewGroup.getOverlay();
+    }
+
+    @Override // androidx.transition.ViewOverlayImpl
+    public void a(Drawable drawable) {
+        this.a.add(drawable);
+    }
+
+    @Override // androidx.transition.ViewOverlayImpl
+    public void b(Drawable drawable) {
+        this.a.remove(drawable);
+    }
+
+    @Override // androidx.transition.ViewGroupOverlayImpl
+    public void a(View view) {
+        this.a.add(view);
+    }
+
+    @Override // androidx.transition.ViewGroupOverlayImpl
+    public void b(View view) {
+        this.a.remove(view);
+    }
+}

sources/androidx/transition/ViewGroupOverlayImpl.java

@@ -0,0 +1,10 @@
+package androidx.transition;
+
+import android.view.View;
+
+/* loaded from: classes.dex */
+interface ViewGroupOverlayImpl extends ViewOverlayImpl {
+    void a(View view);
+
+    void b(View view);
+}

sources/androidx/transition/ViewGroupUtils.java

@@ -0,0 +1,19 @@
+package androidx.transition;
+
+import android.os.Build;
+import android.view.ViewGroup;
+
+/* loaded from: classes.dex */
+class ViewGroupUtils {
+    static ViewGroupOverlayImpl a(ViewGroup viewGroup) {
+        return Build.VERSION.SDK_INT >= 18 ? new ViewGroupOverlayApi18(viewGroup) : ViewGroupOverlayApi14.a(viewGroup);
+    }
+
+    static void a(ViewGroup viewGroup, boolean z) {
+        if (Build.VERSION.SDK_INT >= 18) {
+            ViewGroupUtilsApi18.a(viewGroup, z);
+        } else {
+            ViewGroupUtilsApi14.a(viewGroup, z);
+        }
+    }
+}

sources/androidx/transition/ViewGroupUtilsApi14.java

@@ -0,0 +1,136 @@
+package androidx.transition;
+
+import android.animation.LayoutTransition;
+import android.util.Log;
+import com.ubt.jimu.base.dialog.SimpleQuestionDialog;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/* loaded from: classes.dex */
+class ViewGroupUtilsApi14 {
+    private static LayoutTransition a;
+    private static Field b;
+    private static boolean c;
+    private static Method d;
+    private static boolean e;
+
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0085  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x0092  */
+    /* JADX WARN: Removed duplicated region for block: B:26:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    static void a(android.view.ViewGroup r5, boolean r6) {
+        /*
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            r1 = 1
+            r2 = 0
+            r3 = 0
+            if (r0 != 0) goto L2a
+            androidx.transition.ViewGroupUtilsApi14$1 r0 = new androidx.transition.ViewGroupUtilsApi14$1
+            r0.<init>()
+            androidx.transition.ViewGroupUtilsApi14.a = r0
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            r4 = 2
+            r0.setAnimator(r4, r3)
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            r0.setAnimator(r2, r3)
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            r0.setAnimator(r1, r3)
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            r4 = 3
+            r0.setAnimator(r4, r3)
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            r4 = 4
+            r0.setAnimator(r4, r3)
+        L2a:
+            if (r6 == 0) goto L4a
+            android.animation.LayoutTransition r6 = r5.getLayoutTransition()
+            if (r6 == 0) goto L44
+            boolean r0 = r6.isRunning()
+            if (r0 == 0) goto L3b
+            a(r6)
+        L3b:
+            android.animation.LayoutTransition r0 = androidx.transition.ViewGroupUtilsApi14.a
+            if (r6 == r0) goto L44
+            int r0 = androidx.transition.R$id.transition_layout_save
+            r5.setTag(r0, r6)
+        L44:
+            android.animation.LayoutTransition r6 = androidx.transition.ViewGroupUtilsApi14.a
+            r5.setLayoutTransition(r6)
+            goto L9a
+        L4a:
+            r5.setLayoutTransition(r3)
+            boolean r6 = androidx.transition.ViewGroupUtilsApi14.c
+            java.lang.String r0 = "ViewGroupUtilsApi14"
+            if (r6 != 0) goto L6a
+            java.lang.Class<android.view.ViewGroup> r6 = android.view.ViewGroup.class
+            java.lang.String r4 = "mLayoutSuppressed"
+            java.lang.reflect.Field r6 = r6.getDeclaredField(r4)     // Catch: java.lang.NoSuchFieldException -> L63
+            androidx.transition.ViewGroupUtilsApi14.b = r6     // Catch: java.lang.NoSuchFieldException -> L63
+            java.lang.reflect.Field r6 = androidx.transition.ViewGroupUtilsApi14.b     // Catch: java.lang.NoSuchFieldException -> L63
+            r6.setAccessible(r1)     // Catch: java.lang.NoSuchFieldException -> L63
+            goto L68
+        L63:
+            java.lang.String r6 = "Failed to access mLayoutSuppressed field by reflection"
+            android.util.Log.i(r0, r6)
+        L68:
+            androidx.transition.ViewGroupUtilsApi14.c = r1
+        L6a:
+            java.lang.reflect.Field r6 = androidx.transition.ViewGroupUtilsApi14.b
+            if (r6 == 0) goto L83
+            boolean r6 = r6.getBoolean(r5)     // Catch: java.lang.IllegalAccessException -> L7e
+            if (r6 == 0) goto L7c
+            java.lang.reflect.Field r1 = androidx.transition.ViewGroupUtilsApi14.b     // Catch: java.lang.IllegalAccessException -> L7a
+            r1.setBoolean(r5, r2)     // Catch: java.lang.IllegalAccessException -> L7a
+            goto L7c
+        L7a:
+            r2 = r6
+            goto L7e
+        L7c:
+            r2 = r6
+            goto L83
+        L7e:
+            java.lang.String r6 = "Failed to get mLayoutSuppressed field by reflection"
+            android.util.Log.i(r0, r6)
+        L83:
+            if (r2 == 0) goto L88
+            r5.requestLayout()
+        L88:
+            int r6 = androidx.transition.R$id.transition_layout_save
+            java.lang.Object r6 = r5.getTag(r6)
+            android.animation.LayoutTransition r6 = (android.animation.LayoutTransition) r6
+            if (r6 == 0) goto L9a
+            int r0 = androidx.transition.R$id.transition_layout_save
+            r5.setTag(r0, r3)
+            r5.setLayoutTransition(r6)
+        L9a:
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.transition.ViewGroupUtilsApi14.a(android.view.ViewGroup, boolean):void");
+    }
+
+    private static void a(LayoutTransition layoutTransition) {
+        if (!e) {
+            try {
+                d = LayoutTransition.class.getDeclaredMethod(SimpleQuestionDialog.KEY_CANCELBUTTON, new Class[0]);
+                d.setAccessible(true);
+            } catch (NoSuchMethodException unused) {
+                Log.i("ViewGroupUtilsApi14", "Failed to access cancel method by reflection");
+            }
+            e = true;
+        }
+        Method method = d;
+        if (method != null) {
+            try {
+                method.invoke(layoutTransition, new Object[0]);
+            } catch (IllegalAccessException unused2) {
+                Log.i("ViewGroupUtilsApi14", "Failed to access cancel method by reflection");
+            } catch (InvocationTargetException unused3) {
+                Log.i("ViewGroupUtilsApi14", "Failed to invoke cancel method by reflection");
+            }
+        }
+    }
+}

sources/androidx/transition/ViewGroupUtilsApi18.java

@@ -0,0 +1,39 @@
+package androidx.transition;
+
+import android.util.Log;
+import android.view.ViewGroup;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/* loaded from: classes.dex */
+class ViewGroupUtilsApi18 {
+    private static Method a;
+    private static boolean b;
+
+    static void a(ViewGroup viewGroup, boolean z) {
+        a();
+        Method method = a;
+        if (method != null) {
+            try {
+                method.invoke(viewGroup, Boolean.valueOf(z));
+            } catch (IllegalAccessException e) {
+                Log.i("ViewUtilsApi18", "Failed to invoke suppressLayout method", e);
+            } catch (InvocationTargetException e2) {
+                Log.i("ViewUtilsApi18", "Error invoking suppressLayout method", e2);
+            }
+        }
+    }
+
+    private static void a() {
+        if (b) {
+            return;
+        }
+        try {
+            a = ViewGroup.class.getDeclaredMethod("suppressLayout", Boolean.TYPE);
+            a.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            Log.i("ViewUtilsApi18", "Failed to retrieve suppressLayout method", e);
+        }
+        b = true;
+    }
+}

sources/androidx/transition/ViewOverlayApi14.java

@@ -0,0 +1,196 @@
+package androidx.transition;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import androidx.core.view.ViewCompat;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+class ViewOverlayApi14 implements ViewOverlayImpl {
+    protected OverlayViewGroup a;
+
+    ViewOverlayApi14(Context context, ViewGroup viewGroup, View view) {
+        this.a = new OverlayViewGroup(context, viewGroup, view, this);
+    }
+
+    static ViewOverlayApi14 c(View view) {
+        ViewGroup d = d(view);
+        if (d == null) {
+            return null;
+        }
+        int childCount = d.getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            View childAt = d.getChildAt(i);
+            if (childAt instanceof OverlayViewGroup) {
+                return ((OverlayViewGroup) childAt).d;
+            }
+        }
+        return new ViewGroupOverlayApi14(d.getContext(), d, view);
+    }
+
+    static ViewGroup d(View view) {
+        while (view != null) {
+            if (view.getId() == 16908290 && (view instanceof ViewGroup)) {
+                return (ViewGroup) view;
+            }
+            if (view.getParent() instanceof ViewGroup) {
+                view = (ViewGroup) view.getParent();
+            }
+        }
+        return null;
+    }
+
+    @Override // androidx.transition.ViewOverlayImpl
+    public void a(Drawable drawable) {
+        this.a.a(drawable);
+    }
+
+    @Override // androidx.transition.ViewOverlayImpl
+    public void b(Drawable drawable) {
+        this.a.b(drawable);
+    }
+
+    static class OverlayViewGroup extends ViewGroup {
+        ViewGroup a;
+        View b;
+        ArrayList<Drawable> c;
+        ViewOverlayApi14 d;
+
+        static {
+            try {
+                ViewGroup.class.getDeclaredMethod("invalidateChildInParentFast", Integer.TYPE, Integer.TYPE, Rect.class);
+            } catch (NoSuchMethodException unused) {
+            }
+        }
+
+        OverlayViewGroup(Context context, ViewGroup viewGroup, View view, ViewOverlayApi14 viewOverlayApi14) {
+            super(context);
+            this.c = null;
+            this.a = viewGroup;
+            this.b = view;
+            setRight(viewGroup.getWidth());
+            setBottom(viewGroup.getHeight());
+            viewGroup.addView(this);
+            this.d = viewOverlayApi14;
+        }
+
+        public void a(Drawable drawable) {
+            if (this.c == null) {
+                this.c = new ArrayList<>();
+            }
+            if (this.c.contains(drawable)) {
+                return;
+            }
+            this.c.add(drawable);
+            invalidate(drawable.getBounds());
+            drawable.setCallback(this);
+        }
+
+        public void b(Drawable drawable) {
+            ArrayList<Drawable> arrayList = this.c;
+            if (arrayList != null) {
+                arrayList.remove(drawable);
+                invalidate(drawable.getBounds());
+                drawable.setCallback(null);
+            }
+        }
+
+        @Override // android.view.ViewGroup, android.view.View
+        protected void dispatchDraw(Canvas canvas) {
+            this.a.getLocationOnScreen(new int[2]);
+            this.b.getLocationOnScreen(new int[2]);
+            canvas.translate(r0[0] - r1[0], r0[1] - r1[1]);
+            canvas.clipRect(new Rect(0, 0, this.b.getWidth(), this.b.getHeight()));
+            super.dispatchDraw(canvas);
+            ArrayList<Drawable> arrayList = this.c;
+            int size = arrayList == null ? 0 : arrayList.size();
+            for (int i = 0; i < size; i++) {
+                this.c.get(i).draw(canvas);
+            }
+        }
+
+        @Override // android.view.ViewGroup, android.view.View
+        public boolean dispatchTouchEvent(MotionEvent motionEvent) {
+            return false;
+        }
+
+        @Override // android.view.ViewGroup, android.view.ViewParent
+        public ViewParent invalidateChildInParent(int[] iArr, Rect rect) {
+            if (this.a == null) {
+                return null;
+            }
+            rect.offset(iArr[0], iArr[1]);
+            if (!(this.a instanceof ViewGroup)) {
+                invalidate(rect);
+                return null;
+            }
+            iArr[0] = 0;
+            iArr[1] = 0;
+            int[] iArr2 = new int[2];
+            a(iArr2);
+            rect.offset(iArr2[0], iArr2[1]);
+            return super.invalidateChildInParent(iArr, rect);
+        }
+
+        @Override // android.view.View, android.graphics.drawable.Drawable.Callback
+        public void invalidateDrawable(Drawable drawable) {
+            invalidate(drawable.getBounds());
+        }
+
+        @Override // android.view.ViewGroup, android.view.View
+        protected void onLayout(boolean z, int i, int i2, int i3, int i4) {
+        }
+
+        @Override // android.view.View
+        protected boolean verifyDrawable(Drawable drawable) {
+            ArrayList<Drawable> arrayList;
+            return super.verifyDrawable(drawable) || ((arrayList = this.c) != null && arrayList.contains(drawable));
+        }
+
+        public void b(View view) {
+            super.removeView(view);
+            if (a()) {
+                this.a.removeView(this);
+            }
+        }
+
+        public void a(View view) {
+            if (view.getParent() instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view.getParent();
+                if (viewGroup != this.a && viewGroup.getParent() != null && ViewCompat.w(viewGroup)) {
+                    int[] iArr = new int[2];
+                    int[] iArr2 = new int[2];
+                    viewGroup.getLocationOnScreen(iArr);
+                    this.a.getLocationOnScreen(iArr2);
+                    ViewCompat.c(view, iArr[0] - iArr2[0]);
+                    ViewCompat.d(view, iArr[1] - iArr2[1]);
+                }
+                viewGroup.removeView(view);
+                if (view.getParent() != null) {
+                    viewGroup.removeView(view);
+                }
+            }
+            super.addView(view, getChildCount() - 1);
+        }
+
+        boolean a() {
+            ArrayList<Drawable> arrayList;
+            return getChildCount() == 0 && ((arrayList = this.c) == null || arrayList.size() == 0);
+        }
+
+        private void a(int[] iArr) {
+            int[] iArr2 = new int[2];
+            int[] iArr3 = new int[2];
+            this.a.getLocationOnScreen(iArr2);
+            this.b.getLocationOnScreen(iArr3);
+            iArr[0] = iArr3[0] - iArr2[0];
+            iArr[1] = iArr3[1] - iArr2[1];
+        }
+    }
+}

sources/androidx/transition/ViewOverlayApi18.java

@@ -0,0 +1,24 @@
+package androidx.transition;
+
+import android.graphics.drawable.Drawable;
+import android.view.View;
+import android.view.ViewOverlay;
+
+/* loaded from: classes.dex */
+class ViewOverlayApi18 implements ViewOverlayImpl {
+    private final ViewOverlay a;
+
+    ViewOverlayApi18(View view) {
+        this.a = view.getOverlay();
+    }
+
+    @Override // androidx.transition.ViewOverlayImpl
+    public void a(Drawable drawable) {
+        this.a.add(drawable);
+    }
+
+    @Override // androidx.transition.ViewOverlayImpl
+    public void b(Drawable drawable) {
+        this.a.remove(drawable);
+    }
+}

sources/androidx/transition/ViewOverlayImpl.java

@@ -0,0 +1,10 @@
+package androidx.transition;
+
+import android.graphics.drawable.Drawable;
+
+/* loaded from: classes.dex */
+interface ViewOverlayImpl {
+    void a(Drawable drawable);
+
+    void b(Drawable drawable);
+}

sources/androidx/transition/ViewUtils.java

@@ -0,0 +1,117 @@
+package androidx.transition;
+
+import android.graphics.Matrix;
+import android.graphics.Rect;
+import android.os.Build;
+import android.util.Log;
+import android.util.Property;
+import android.view.View;
+import androidx.core.view.ViewCompat;
+import java.lang.reflect.Field;
+
+/* loaded from: classes.dex */
+class ViewUtils {
+    private static final ViewUtilsBase a;
+    private static Field b;
+    private static boolean c;
+    static final Property<View, Float> d;
+
+    static {
+        int i = Build.VERSION.SDK_INT;
+        if (i >= 22) {
+            a = new ViewUtilsApi22();
+        } else if (i >= 21) {
+            a = new ViewUtilsApi21();
+        } else if (i >= 19) {
+            a = new ViewUtilsApi19();
+        } else {
+            a = new ViewUtilsBase();
+        }
+        d = new Property<View, Float>(Float.class, "translationAlpha") { // from class: androidx.transition.ViewUtils.1
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public Float get(View view) {
+                return Float.valueOf(ViewUtils.c(view));
+            }
+
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void set(View view, Float f) {
+                ViewUtils.a(view, f.floatValue());
+            }
+        };
+        new Property<View, Rect>(Rect.class, "clipBounds") { // from class: androidx.transition.ViewUtils.2
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public Rect get(View view) {
+                return ViewCompat.e(view);
+            }
+
+            @Override // android.util.Property
+            /* renamed from: a, reason: merged with bridge method [inline-methods] */
+            public void set(View view, Rect rect) {
+                ViewCompat.a(view, rect);
+            }
+        };
+    }
+
+    static void a(View view, float f) {
+        a.a(view, f);
+    }
+
+    static ViewOverlayImpl b(View view) {
+        return Build.VERSION.SDK_INT >= 18 ? new ViewOverlayApi18(view) : ViewOverlayApi14.c(view);
+    }
+
+    static float c(View view) {
+        return a.b(view);
+    }
+
+    static WindowIdImpl d(View view) {
+        return Build.VERSION.SDK_INT >= 18 ? new WindowIdApi18(view) : new WindowIdApi14(view.getWindowToken());
+    }
+
+    static void e(View view) {
+        a.c(view);
+    }
+
+    static void a(View view) {
+        a.a(view);
+    }
+
+    static void a(View view, int i) {
+        a();
+        Field field = b;
+        if (field != null) {
+            try {
+                b.setInt(view, i | (field.getInt(view) & (-13)));
+            } catch (IllegalAccessException unused) {
+            }
+        }
+    }
+
+    static void b(View view, Matrix matrix) {
+        a.b(view, matrix);
+    }
+
+    static void a(View view, Matrix matrix) {
+        a.a(view, matrix);
+    }
+
+    static void a(View view, int i, int i2, int i3, int i4) {
+        a.a(view, i, i2, i3, i4);
+    }
+
+    private static void a() {
+        if (c) {
+            return;
+        }
+        try {
+            b = View.class.getDeclaredField("mViewFlags");
+            b.setAccessible(true);
+        } catch (NoSuchFieldException unused) {
+            Log.i("ViewUtils", "fetchViewFlagsField: ");
+        }
+        c = true;
+    }
+}

sources/androidx/transition/ViewUtilsApi19.java

@@ -0,0 +1,82 @@
+package androidx.transition;
+
+import android.util.Log;
+import android.view.View;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/* loaded from: classes.dex */
+class ViewUtilsApi19 extends ViewUtilsBase {
+    private static Method a;
+    private static boolean b;
+    private static Method c;
+    private static boolean d;
+
+    ViewUtilsApi19() {
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public void a(View view) {
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public void a(View view, float f) {
+        b();
+        Method method = a;
+        if (method == null) {
+            view.setAlpha(f);
+            return;
+        }
+        try {
+            method.invoke(view, Float.valueOf(f));
+        } catch (IllegalAccessException unused) {
+        } catch (InvocationTargetException e) {
+            throw new RuntimeException(e.getCause());
+        }
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public float b(View view) {
+        a();
+        Method method = c;
+        if (method != null) {
+            try {
+                return ((Float) method.invoke(view, new Object[0])).floatValue();
+            } catch (IllegalAccessException unused) {
+            } catch (InvocationTargetException e) {
+                throw new RuntimeException(e.getCause());
+            }
+        }
+        return super.b(view);
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public void c(View view) {
+    }
+
+    private void a() {
+        if (d) {
+            return;
+        }
+        try {
+            c = View.class.getDeclaredMethod("getTransitionAlpha", new Class[0]);
+            c.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            Log.i("ViewUtilsApi19", "Failed to retrieve getTransitionAlpha method", e);
+        }
+        d = true;
+    }
+
+    private void b() {
+        if (b) {
+            return;
+        }
+        try {
+            a = View.class.getDeclaredMethod("setTransitionAlpha", Float.TYPE);
+            a.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            Log.i("ViewUtilsApi19", "Failed to retrieve setTransitionAlpha method", e);
+        }
+        b = true;
+    }
+}

sources/androidx/transition/ViewUtilsApi21.java

@@ -0,0 +1,72 @@
+package androidx.transition;
+
+import android.graphics.Matrix;
+import android.util.Log;
+import android.view.View;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/* loaded from: classes.dex */
+class ViewUtilsApi21 extends ViewUtilsApi19 {
+    private static Method e;
+    private static boolean f;
+    private static Method g;
+    private static boolean h;
+
+    ViewUtilsApi21() {
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public void a(View view, Matrix matrix) {
+        a();
+        Method method = e;
+        if (method != null) {
+            try {
+                method.invoke(view, matrix);
+            } catch (IllegalAccessException unused) {
+            } catch (InvocationTargetException e2) {
+                throw new RuntimeException(e2.getCause());
+            }
+        }
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public void b(View view, Matrix matrix) {
+        b();
+        Method method = g;
+        if (method != null) {
+            try {
+                method.invoke(view, matrix);
+            } catch (IllegalAccessException unused) {
+            } catch (InvocationTargetException e2) {
+                throw new RuntimeException(e2.getCause());
+            }
+        }
+    }
+
+    private void a() {
+        if (f) {
+            return;
+        }
+        try {
+            e = View.class.getDeclaredMethod("transformMatrixToGlobal", Matrix.class);
+            e.setAccessible(true);
+        } catch (NoSuchMethodException e2) {
+            Log.i("ViewUtilsApi21", "Failed to retrieve transformMatrixToGlobal method", e2);
+        }
+        f = true;
+    }
+
+    private void b() {
+        if (h) {
+            return;
+        }
+        try {
+            g = View.class.getDeclaredMethod("transformMatrixToLocal", Matrix.class);
+            g.setAccessible(true);
+        } catch (NoSuchMethodException e2) {
+            Log.i("ViewUtilsApi21", "Failed to retrieve transformMatrixToLocal method", e2);
+        }
+        h = true;
+    }
+}

sources/androidx/transition/ViewUtilsApi22.java

@@ -0,0 +1,44 @@
+package androidx.transition;
+
+import android.annotation.SuppressLint;
+import android.util.Log;
+import android.view.View;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/* loaded from: classes.dex */
+class ViewUtilsApi22 extends ViewUtilsApi21 {
+    private static Method i;
+    private static boolean j;
+
+    ViewUtilsApi22() {
+    }
+
+    @Override // androidx.transition.ViewUtilsBase
+    public void a(View view, int i2, int i3, int i4, int i5) {
+        a();
+        Method method = i;
+        if (method != null) {
+            try {
+                method.invoke(view, Integer.valueOf(i2), Integer.valueOf(i3), Integer.valueOf(i4), Integer.valueOf(i5));
+            } catch (IllegalAccessException unused) {
+            } catch (InvocationTargetException e) {
+                throw new RuntimeException(e.getCause());
+            }
+        }
+    }
+
+    @SuppressLint({"PrivateApi"})
+    private void a() {
+        if (j) {
+            return;
+        }
+        try {
+            i = View.class.getDeclaredMethod("setLeftTopRightBottom", Integer.TYPE, Integer.TYPE, Integer.TYPE, Integer.TYPE);
+            i.setAccessible(true);
+        } catch (NoSuchMethodException e) {
+            Log.i("ViewUtilsApi22", "Failed to retrieve setLeftTopRightBottom method", e);
+        }
+        j = true;
+    }
+}

sources/androidx/transition/ViewUtilsBase.java

@@ -0,0 +1,74 @@
+package androidx.transition;
+
+import android.graphics.Matrix;
+import android.view.View;
+
+/* loaded from: classes.dex */
+class ViewUtilsBase {
+    ViewUtilsBase() {
+    }
+
+    public void a(View view, float f) {
+        Float f2 = (Float) view.getTag(R$id.save_non_transition_alpha);
+        if (f2 != null) {
+            view.setAlpha(f2.floatValue() * f);
+        } else {
+            view.setAlpha(f);
+        }
+    }
+
+    public float b(View view) {
+        Float f = (Float) view.getTag(R$id.save_non_transition_alpha);
+        return f != null ? view.getAlpha() / f.floatValue() : view.getAlpha();
+    }
+
+    public void c(View view) {
+        if (view.getTag(R$id.save_non_transition_alpha) == null) {
+            view.setTag(R$id.save_non_transition_alpha, Float.valueOf(view.getAlpha()));
+        }
+    }
+
+    public void a(View view) {
+        if (view.getVisibility() == 0) {
+            view.setTag(R$id.save_non_transition_alpha, null);
+        }
+    }
+
+    public void b(View view, Matrix matrix) {
+        Object parent = view.getParent();
+        if (parent instanceof View) {
+            b((View) parent, matrix);
+            matrix.postTranslate(r0.getScrollX(), r0.getScrollY());
+        }
+        matrix.postTranslate(view.getLeft(), view.getTop());
+        Matrix matrix2 = view.getMatrix();
+        if (matrix2.isIdentity()) {
+            return;
+        }
+        Matrix matrix3 = new Matrix();
+        if (matrix2.invert(matrix3)) {
+            matrix.postConcat(matrix3);
+        }
+    }
+
+    public void a(View view, Matrix matrix) {
+        Object parent = view.getParent();
+        if (parent instanceof View) {
+            a((View) parent, matrix);
+            matrix.preTranslate(-r0.getScrollX(), -r0.getScrollY());
+        }
+        matrix.preTranslate(view.getLeft(), view.getTop());
+        Matrix matrix2 = view.getMatrix();
+        if (matrix2.isIdentity()) {
+            return;
+        }
+        matrix.preConcat(matrix2);
+    }
+
+    public void a(View view, int i, int i2, int i3, int i4) {
+        view.setLeft(i);
+        view.setTop(i2);
+        view.setRight(i3);
+        view.setBottom(i4);
+    }
+}

sources/androidx/transition/Visibility.java

@@ -0,0 +1,260 @@
+package androidx.transition;
+
+import android.animation.Animator;
+import android.animation.AnimatorListenerAdapter;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.transition.AnimatorUtils;
+import androidx.transition.Transition;
+
+/* loaded from: classes.dex */
+public abstract class Visibility extends Transition {
+    private static final String[] L = {"android:visibility:visibility", "android:visibility:parent"};
+    private int K = 3;
+
+    private static class VisibilityInfo {
+        boolean a;
+        boolean b;
+        int c;
+        int d;
+        ViewGroup e;
+        ViewGroup f;
+
+        VisibilityInfo() {
+        }
+    }
+
+    private VisibilityInfo b(TransitionValues transitionValues, TransitionValues transitionValues2) {
+        VisibilityInfo visibilityInfo = new VisibilityInfo();
+        visibilityInfo.a = false;
+        visibilityInfo.b = false;
+        if (transitionValues == null || !transitionValues.a.containsKey("android:visibility:visibility")) {
+            visibilityInfo.c = -1;
+            visibilityInfo.e = null;
+        } else {
+            visibilityInfo.c = ((Integer) transitionValues.a.get("android:visibility:visibility")).intValue();
+            visibilityInfo.e = (ViewGroup) transitionValues.a.get("android:visibility:parent");
+        }
+        if (transitionValues2 == null || !transitionValues2.a.containsKey("android:visibility:visibility")) {
+            visibilityInfo.d = -1;
+            visibilityInfo.f = null;
+        } else {
+            visibilityInfo.d = ((Integer) transitionValues2.a.get("android:visibility:visibility")).intValue();
+            visibilityInfo.f = (ViewGroup) transitionValues2.a.get("android:visibility:parent");
+        }
+        if (transitionValues == null || transitionValues2 == null) {
+            if (transitionValues == null && visibilityInfo.d == 0) {
+                visibilityInfo.b = true;
+                visibilityInfo.a = true;
+            } else if (transitionValues2 == null && visibilityInfo.c == 0) {
+                visibilityInfo.b = false;
+                visibilityInfo.a = true;
+            }
+        } else {
+            if (visibilityInfo.c == visibilityInfo.d && visibilityInfo.e == visibilityInfo.f) {
+                return visibilityInfo;
+            }
+            int i = visibilityInfo.c;
+            int i2 = visibilityInfo.d;
+            if (i != i2) {
+                if (i == 0) {
+                    visibilityInfo.b = false;
+                    visibilityInfo.a = true;
+                } else if (i2 == 0) {
+                    visibilityInfo.b = true;
+                    visibilityInfo.a = true;
+                }
+            } else if (visibilityInfo.f == null) {
+                visibilityInfo.b = false;
+                visibilityInfo.a = true;
+            } else if (visibilityInfo.e == null) {
+                visibilityInfo.b = true;
+                visibilityInfo.a = true;
+            }
+        }
+        return visibilityInfo;
+    }
+
+    private void d(TransitionValues transitionValues) {
+        transitionValues.a.put("android:visibility:visibility", Integer.valueOf(transitionValues.b.getVisibility()));
+        transitionValues.a.put("android:visibility:parent", transitionValues.b.getParent());
+        int[] iArr = new int[2];
+        transitionValues.b.getLocationOnScreen(iArr);
+        transitionValues.a.put("android:visibility:screenLocation", iArr);
+    }
+
+    public abstract Animator a(ViewGroup viewGroup, View view, TransitionValues transitionValues, TransitionValues transitionValues2);
+
+    public void a(int i) {
+        if ((i & (-4)) != 0) {
+            throw new IllegalArgumentException("Only MODE_IN and MODE_OUT flags are allowed");
+        }
+        this.K = i;
+    }
+
+    public abstract Animator b(ViewGroup viewGroup, View view, TransitionValues transitionValues, TransitionValues transitionValues2);
+
+    @Override // androidx.transition.Transition
+    public void c(TransitionValues transitionValues) {
+        d(transitionValues);
+    }
+
+    @Override // androidx.transition.Transition
+    public String[] r() {
+        return L;
+    }
+
+    @Override // androidx.transition.Transition
+    public void a(TransitionValues transitionValues) {
+        d(transitionValues);
+    }
+
+    @Override // androidx.transition.Transition
+    public Animator a(ViewGroup viewGroup, TransitionValues transitionValues, TransitionValues transitionValues2) {
+        VisibilityInfo b = b(transitionValues, transitionValues2);
+        if (!b.a) {
+            return null;
+        }
+        if (b.e == null && b.f == null) {
+            return null;
+        }
+        if (b.b) {
+            return a(viewGroup, transitionValues, b.c, transitionValues2, b.d);
+        }
+        return b(viewGroup, transitionValues, b.c, transitionValues2, b.d);
+    }
+
+    private static class DisappearListener extends AnimatorListenerAdapter implements Transition.TransitionListener, AnimatorUtils.AnimatorPauseListenerCompat {
+        private final View a;
+        private final int b;
+        private final ViewGroup c;
+        private final boolean d;
+        private boolean e;
+        boolean f = false;
+
+        DisappearListener(View view, int i, boolean z) {
+            this.a = view;
+            this.b = i;
+            this.c = (ViewGroup) view.getParent();
+            this.d = z;
+            a(true);
+        }
+
+        private void a() {
+            if (!this.f) {
+                ViewUtils.a(this.a, this.b);
+                ViewGroup viewGroup = this.c;
+                if (viewGroup != null) {
+                    viewGroup.invalidate();
+                }
+            }
+            a(false);
+        }
+
+        @Override // androidx.transition.Transition.TransitionListener
+        public void a(Transition transition) {
+        }
+
+        @Override // androidx.transition.Transition.TransitionListener
+        public void b(Transition transition) {
+            a(false);
+        }
+
+        @Override // androidx.transition.Transition.TransitionListener
+        public void c(Transition transition) {
+            a();
+            transition.b(this);
+        }
+
+        @Override // androidx.transition.Transition.TransitionListener
+        public void d(Transition transition) {
+            a(true);
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+        public void onAnimationCancel(Animator animator) {
+            this.f = true;
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+        public void onAnimationEnd(Animator animator) {
+            a();
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorPauseListener, androidx.transition.AnimatorUtils.AnimatorPauseListenerCompat
+        public void onAnimationPause(Animator animator) {
+            if (this.f) {
+                return;
+            }
+            ViewUtils.a(this.a, this.b);
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+        public void onAnimationRepeat(Animator animator) {
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorPauseListener, androidx.transition.AnimatorUtils.AnimatorPauseListenerCompat
+        public void onAnimationResume(Animator animator) {
+            if (this.f) {
+                return;
+            }
+            ViewUtils.a(this.a, 0);
+        }
+
+        @Override // android.animation.AnimatorListenerAdapter, android.animation.Animator.AnimatorListener
+        public void onAnimationStart(Animator animator) {
+        }
+
+        private void a(boolean z) {
+            ViewGroup viewGroup;
+            if (!this.d || this.e == z || (viewGroup = this.c) == null) {
+                return;
+            }
+            this.e = z;
+            ViewGroupUtils.a(viewGroup, z);
+        }
+    }
+
+    public Animator a(ViewGroup viewGroup, TransitionValues transitionValues, int i, TransitionValues transitionValues2, int i2) {
+        if ((this.K & 1) != 1 || transitionValues2 == null) {
+            return null;
+        }
+        if (transitionValues == null) {
+            View view = (View) transitionValues2.b.getParent();
+            if (b(a(view, false), b(view, false)).a) {
+                return null;
+            }
+        }
+        return a(viewGroup, transitionValues2.b, transitionValues, transitionValues2);
+    }
+
+    @Override // androidx.transition.Transition
+    public boolean a(TransitionValues transitionValues, TransitionValues transitionValues2) {
+        if (transitionValues == null && transitionValues2 == null) {
+            return false;
+        }
+        if (transitionValues != null && transitionValues2 != null && transitionValues2.a.containsKey("android:visibility:visibility") != transitionValues.a.containsKey("android:visibility:visibility")) {
+            return false;
+        }
+        VisibilityInfo b = b(transitionValues, transitionValues2);
+        if (b.a) {
+            return b.c == 0 || b.d == 0;
+        }
+        return false;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:22:0x0087 A[ADDED_TO_REGION] */
+    /* JADX WARN: Removed duplicated region for block: B:29:0x00ce  */
+    /* JADX WARN: Removed duplicated region for block: B:34:0x00ee A[RETURN] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct code enable 'Show inconsistent code' option in preferences
+    */
+    public android.animation.Animator b(android.view.ViewGroup r7, androidx.transition.TransitionValues r8, int r9, androidx.transition.TransitionValues r10, int r11) {
+        /*
+            Method dump skipped, instructions count: 239
+            To view this dump change 'Code comments level' option to 'DEBUG'
+        */
+        throw new UnsupportedOperationException("Method not decompiled: androidx.transition.Visibility.b(android.view.ViewGroup, androidx.transition.TransitionValues, int, androidx.transition.TransitionValues, int):android.animation.Animator");
+    }
+}

sources/androidx/transition/WindowIdApi14.java

@@ -0,0 +1,20 @@
+package androidx.transition;
+
+import android.os.IBinder;
+
+/* loaded from: classes.dex */
+class WindowIdApi14 implements WindowIdImpl {
+    private final IBinder a;
+
+    WindowIdApi14(IBinder iBinder) {
+        this.a = iBinder;
+    }
+
+    public boolean equals(Object obj) {
+        return (obj instanceof WindowIdApi14) && ((WindowIdApi14) obj).a.equals(this.a);
+    }
+
+    public int hashCode() {
+        return this.a.hashCode();
+    }
+}

sources/androidx/transition/WindowIdApi18.java

@@ -0,0 +1,21 @@
+package androidx.transition;
+
+import android.view.View;
+import android.view.WindowId;
+
+/* loaded from: classes.dex */
+class WindowIdApi18 implements WindowIdImpl {
+    private final WindowId a;
+
+    WindowIdApi18(View view) {
+        this.a = view.getWindowId();
+    }
+
+    public boolean equals(Object obj) {
+        return (obj instanceof WindowIdApi18) && ((WindowIdApi18) obj).a.equals(this.a);
+    }
+
+    public int hashCode() {
+        return this.a.hashCode();
+    }
+}

sources/androidx/transition/WindowIdImpl.java

@@ -0,0 +1,5 @@
+package androidx.transition;
+
+/* loaded from: classes.dex */
+interface WindowIdImpl {
+}