Add decompiled APK source code (JADX)

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

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

decompiled/sources/androidx/appcompat/graphics/drawable/AnimatedStateListDrawableCompat.java

@@ -0,0 +1,555 @@
+package androidx.appcompat.graphics.drawable;
+
+import android.animation.ObjectAnimator;
+import android.animation.TimeInterpolator;
+import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.TypedArray;
+import android.content.res.XmlResourceParser;
+import android.graphics.drawable.Animatable;
+import android.graphics.drawable.AnimationDrawable;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.util.StateSet;
+import android.util.Xml;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.graphics.drawable.DrawableContainerCompat;
+import androidx.appcompat.graphics.drawable.StateListDrawableCompat;
+import androidx.appcompat.resources.Compatibility;
+import androidx.appcompat.resources.R;
+import androidx.appcompat.widget.ResourceManagerInternal;
+import androidx.collection.LongSparseArray;
+import androidx.collection.SparseArrayCompat;
+import androidx.core.content.res.TypedArrayUtils;
+import androidx.core.graphics.drawable.TintAwareDrawable;
+import androidx.core.util.ObjectsCompat;
+import androidx.vectordrawable.graphics.drawable.AnimatedVectorDrawableCompat;
+import androidx.vectordrawable.graphics.drawable.VectorDrawableCompat;
+import java.io.IOException;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public class AnimatedStateListDrawableCompat extends StateListDrawableCompat implements TintAwareDrawable {
+    private static final String ELEMENT_ITEM = "item";
+    private static final String ELEMENT_TRANSITION = "transition";
+    private static final String ITEM_MISSING_DRAWABLE_ERROR = ": <item> tag requires a 'drawable' attribute or child tag defining a drawable";
+    private static final String LOGTAG = "AnimatedStateListDrawableCompat";
+    private static final String TRANSITION_MISSING_DRAWABLE_ERROR = ": <transition> tag requires a 'drawable' attribute or child tag defining a drawable";
+    private static final String TRANSITION_MISSING_FROM_TO_ID = ": <transition> tag requires 'fromId' & 'toId' attributes";
+    private boolean mMutated;
+    private AnimatedStateListState mState;
+    private Transition mTransition;
+    private int mTransitionFromIndex;
+    private int mTransitionToIndex;
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat, androidx.appcompat.graphics.drawable.DrawableContainerCompat, android.graphics.drawable.Drawable
+    public boolean isStateful() {
+        return true;
+    }
+
+    public AnimatedStateListDrawableCompat() {
+        this(null, null);
+    }
+
+    public AnimatedStateListDrawableCompat(@Nullable AnimatedStateListState animatedStateListState, @Nullable Resources resources) {
+        super(null);
+        this.mTransitionToIndex = -1;
+        this.mTransitionFromIndex = -1;
+        setConstantState(new AnimatedStateListState(animatedStateListState, this, resources));
+        onStateChange(getState());
+        jumpToCurrentState();
+    }
+
+    @Nullable
+    public static AnimatedStateListDrawableCompat create(@NonNull Context context, @DrawableRes int i, @Nullable Resources.Theme theme) {
+        int next;
+        try {
+            Resources resources = context.getResources();
+            XmlResourceParser xml = resources.getXml(i);
+            AttributeSet asAttributeSet = Xml.asAttributeSet(xml);
+            do {
+                next = xml.next();
+                if (next == 2) {
+                    break;
+                }
+            } while (next != 1);
+            if (next != 2) {
+                throw new XmlPullParserException("No start tag found");
+            }
+            return createFromXmlInner(context, resources, xml, asAttributeSet, theme);
+        } catch (IOException e) {
+            Log.e(LOGTAG, "parser error", e);
+            return null;
+        } catch (XmlPullParserException e2) {
+            Log.e(LOGTAG, "parser error", e2);
+            return null;
+        }
+    }
+
+    @NonNull
+    public static AnimatedStateListDrawableCompat createFromXmlInner(@NonNull Context context, @NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws IOException, XmlPullParserException {
+        String name = xmlPullParser.getName();
+        if (!name.equals("animated-selector")) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ": invalid animated-selector tag " + name);
+        }
+        AnimatedStateListDrawableCompat animatedStateListDrawableCompat = new AnimatedStateListDrawableCompat();
+        animatedStateListDrawableCompat.inflate(context, resources, xmlPullParser, attributeSet, theme);
+        return animatedStateListDrawableCompat;
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat
+    public void inflate(@NonNull Context context, @NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, R.styleable.AnimatedStateListDrawableCompat);
+        setVisible(obtainAttributes.getBoolean(R.styleable.AnimatedStateListDrawableCompat_android_visible, true), true);
+        updateStateFromTypedArray(obtainAttributes);
+        updateDensity(resources);
+        obtainAttributes.recycle();
+        inflateChildElements(context, resources, xmlPullParser, attributeSet, theme);
+        init();
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.DrawableContainerCompat, android.graphics.drawable.Drawable
+    public boolean setVisible(boolean z, boolean z2) {
+        boolean visible = super.setVisible(z, z2);
+        Transition transition = this.mTransition;
+        if (transition != null && (visible || z2)) {
+            if (z) {
+                transition.start();
+            } else {
+                jumpToCurrentState();
+            }
+        }
+        return visible;
+    }
+
+    public void addState(@NonNull int[] iArr, @NonNull Drawable drawable, int i) {
+        ObjectsCompat.requireNonNull(drawable);
+        this.mState.addStateSet(iArr, drawable, i);
+        onStateChange(getState());
+    }
+
+    public <T extends Drawable & Animatable> void addTransition(int i, int i2, @NonNull T t, boolean z) {
+        ObjectsCompat.requireNonNull(t);
+        this.mState.addTransition(i, i2, t, z);
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.DrawableContainerCompat, android.graphics.drawable.Drawable
+    public void jumpToCurrentState() {
+        super.jumpToCurrentState();
+        Transition transition = this.mTransition;
+        if (transition != null) {
+            transition.stop();
+            this.mTransition = null;
+            selectDrawable(this.mTransitionToIndex);
+            this.mTransitionToIndex = -1;
+            this.mTransitionFromIndex = -1;
+        }
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat, androidx.appcompat.graphics.drawable.DrawableContainerCompat, android.graphics.drawable.Drawable
+    public boolean onStateChange(@NonNull int[] iArr) {
+        int indexOfKeyframe = this.mState.indexOfKeyframe(iArr);
+        boolean z = indexOfKeyframe != getCurrentIndex() && (selectTransition(indexOfKeyframe) || selectDrawable(indexOfKeyframe));
+        Drawable current = getCurrent();
+        return current != null ? z | current.setState(iArr) : z;
+    }
+
+    private boolean selectTransition(int i) {
+        int currentIndex;
+        int indexOfTransition;
+        Transition animatableTransition;
+        Transition transition = this.mTransition;
+        if (transition == null) {
+            currentIndex = getCurrentIndex();
+        } else {
+            if (i == this.mTransitionToIndex) {
+                return true;
+            }
+            if (i == this.mTransitionFromIndex && transition.canReverse()) {
+                transition.reverse();
+                this.mTransitionToIndex = this.mTransitionFromIndex;
+                this.mTransitionFromIndex = i;
+                return true;
+            }
+            currentIndex = this.mTransitionToIndex;
+            transition.stop();
+        }
+        this.mTransition = null;
+        this.mTransitionFromIndex = -1;
+        this.mTransitionToIndex = -1;
+        AnimatedStateListState animatedStateListState = this.mState;
+        int keyframeIdAt = animatedStateListState.getKeyframeIdAt(currentIndex);
+        int keyframeIdAt2 = animatedStateListState.getKeyframeIdAt(i);
+        if (keyframeIdAt2 == 0 || keyframeIdAt == 0 || (indexOfTransition = animatedStateListState.indexOfTransition(keyframeIdAt, keyframeIdAt2)) < 0) {
+            return false;
+        }
+        boolean transitionHasReversibleFlag = animatedStateListState.transitionHasReversibleFlag(keyframeIdAt, keyframeIdAt2);
+        selectDrawable(indexOfTransition);
+        Object current = getCurrent();
+        if (current instanceof AnimationDrawable) {
+            animatableTransition = new AnimationDrawableTransition((AnimationDrawable) current, animatedStateListState.isTransitionReversed(keyframeIdAt, keyframeIdAt2), transitionHasReversibleFlag);
+        } else if (current instanceof AnimatedVectorDrawableCompat) {
+            animatableTransition = new AnimatedVectorDrawableTransition((AnimatedVectorDrawableCompat) current);
+        } else {
+            if (current instanceof Animatable) {
+                animatableTransition = new AnimatableTransition((Animatable) current);
+            }
+            return false;
+        }
+        animatableTransition.start();
+        this.mTransition = animatableTransition;
+        this.mTransitionFromIndex = currentIndex;
+        this.mTransitionToIndex = i;
+        return true;
+    }
+
+    public static abstract class Transition {
+        public boolean canReverse() {
+            return false;
+        }
+
+        public void reverse() {
+        }
+
+        public abstract void start();
+
+        public abstract void stop();
+
+        private Transition() {
+        }
+    }
+
+    public static class AnimatableTransition extends Transition {
+        private final Animatable mA;
+
+        public AnimatableTransition(Animatable animatable) {
+            super();
+            this.mA = animatable;
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void start() {
+            this.mA.start();
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void stop() {
+            this.mA.stop();
+        }
+    }
+
+    public static class AnimationDrawableTransition extends Transition {
+        private final ObjectAnimator mAnim;
+        private final boolean mHasReversibleFlag;
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public boolean canReverse() {
+            return this.mHasReversibleFlag;
+        }
+
+        public AnimationDrawableTransition(AnimationDrawable animationDrawable, boolean z, boolean z2) {
+            super();
+            int numberOfFrames = animationDrawable.getNumberOfFrames();
+            int i = z ? numberOfFrames - 1 : 0;
+            int i2 = z ? 0 : numberOfFrames - 1;
+            FrameInterpolator frameInterpolator = new FrameInterpolator(animationDrawable, z);
+            ObjectAnimator ofInt = ObjectAnimator.ofInt(animationDrawable, "currentIndex", i, i2);
+            ofInt.setAutoCancel(true);
+            ofInt.setDuration(frameInterpolator.getTotalDuration());
+            ofInt.setInterpolator(frameInterpolator);
+            this.mHasReversibleFlag = z2;
+            this.mAnim = ofInt;
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void start() {
+            this.mAnim.start();
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void reverse() {
+            this.mAnim.reverse();
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void stop() {
+            this.mAnim.cancel();
+        }
+    }
+
+    public static class AnimatedVectorDrawableTransition extends Transition {
+        private final AnimatedVectorDrawableCompat mAvd;
+
+        public AnimatedVectorDrawableTransition(AnimatedVectorDrawableCompat animatedVectorDrawableCompat) {
+            super();
+            this.mAvd = animatedVectorDrawableCompat;
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void start() {
+            this.mAvd.start();
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat.Transition
+        public void stop() {
+            this.mAvd.stop();
+        }
+    }
+
+    private void updateStateFromTypedArray(TypedArray typedArray) {
+        AnimatedStateListState animatedStateListState = this.mState;
+        animatedStateListState.mChangingConfigurations |= Compatibility.Api21Impl.getChangingConfigurations(typedArray);
+        animatedStateListState.setVariablePadding(typedArray.getBoolean(R.styleable.AnimatedStateListDrawableCompat_android_variablePadding, animatedStateListState.mVariablePadding));
+        animatedStateListState.setConstantSize(typedArray.getBoolean(R.styleable.AnimatedStateListDrawableCompat_android_constantSize, animatedStateListState.mConstantSize));
+        animatedStateListState.setEnterFadeDuration(typedArray.getInt(R.styleable.AnimatedStateListDrawableCompat_android_enterFadeDuration, animatedStateListState.mEnterFadeDuration));
+        animatedStateListState.setExitFadeDuration(typedArray.getInt(R.styleable.AnimatedStateListDrawableCompat_android_exitFadeDuration, animatedStateListState.mExitFadeDuration));
+        setDither(typedArray.getBoolean(R.styleable.AnimatedStateListDrawableCompat_android_dither, animatedStateListState.mDither));
+    }
+
+    private void init() {
+        onStateChange(getState());
+    }
+
+    private void inflateChildElements(@NonNull Context context, @NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        int depth = xmlPullParser.getDepth() + 1;
+        while (true) {
+            int next = xmlPullParser.next();
+            if (next == 1) {
+                return;
+            }
+            int depth2 = xmlPullParser.getDepth();
+            if (depth2 < depth && next == 3) {
+                return;
+            }
+            if (next == 2 && depth2 <= depth) {
+                if (xmlPullParser.getName().equals(ELEMENT_ITEM)) {
+                    parseItem(context, resources, xmlPullParser, attributeSet, theme);
+                } else if (xmlPullParser.getName().equals(ELEMENT_TRANSITION)) {
+                    parseTransition(context, resources, xmlPullParser, attributeSet, theme);
+                }
+            }
+        }
+    }
+
+    private int parseTransition(@NonNull Context context, @NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        int next;
+        TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, R.styleable.AnimatedStateListDrawableTransition);
+        int resourceId = obtainAttributes.getResourceId(R.styleable.AnimatedStateListDrawableTransition_android_fromId, -1);
+        int resourceId2 = obtainAttributes.getResourceId(R.styleable.AnimatedStateListDrawableTransition_android_toId, -1);
+        int resourceId3 = obtainAttributes.getResourceId(R.styleable.AnimatedStateListDrawableTransition_android_drawable, -1);
+        Drawable drawable = resourceId3 > 0 ? ResourceManagerInternal.get().getDrawable(context, resourceId3) : null;
+        boolean z = obtainAttributes.getBoolean(R.styleable.AnimatedStateListDrawableTransition_android_reversible, false);
+        obtainAttributes.recycle();
+        if (drawable == null) {
+            do {
+                next = xmlPullParser.next();
+            } while (next == 4);
+            if (next != 2) {
+                throw new XmlPullParserException(xmlPullParser.getPositionDescription() + TRANSITION_MISSING_DRAWABLE_ERROR);
+            }
+            if (xmlPullParser.getName().equals("animated-vector")) {
+                drawable = AnimatedVectorDrawableCompat.createFromXmlInner(context, resources, xmlPullParser, attributeSet, theme);
+            } else {
+                drawable = Compatibility.Api21Impl.createFromXmlInner(resources, xmlPullParser, attributeSet, theme);
+            }
+        }
+        if (drawable == null) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + TRANSITION_MISSING_DRAWABLE_ERROR);
+        }
+        if (resourceId == -1 || resourceId2 == -1) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + TRANSITION_MISSING_FROM_TO_ID);
+        }
+        return this.mState.addTransition(resourceId, resourceId2, drawable, z);
+    }
+
+    private int parseItem(@NonNull Context context, @NonNull Resources resources, @NonNull XmlPullParser xmlPullParser, @NonNull AttributeSet attributeSet, @Nullable Resources.Theme theme) throws XmlPullParserException, IOException {
+        int next;
+        TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, R.styleable.AnimatedStateListDrawableItem);
+        int resourceId = obtainAttributes.getResourceId(R.styleable.AnimatedStateListDrawableItem_android_id, 0);
+        int resourceId2 = obtainAttributes.getResourceId(R.styleable.AnimatedStateListDrawableItem_android_drawable, -1);
+        Drawable drawable = resourceId2 > 0 ? ResourceManagerInternal.get().getDrawable(context, resourceId2) : null;
+        obtainAttributes.recycle();
+        int[] extractStateSet = extractStateSet(attributeSet);
+        if (drawable == null) {
+            do {
+                next = xmlPullParser.next();
+            } while (next == 4);
+            if (next != 2) {
+                throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ITEM_MISSING_DRAWABLE_ERROR);
+            }
+            if (xmlPullParser.getName().equals("vector")) {
+                drawable = VectorDrawableCompat.createFromXmlInner(resources, xmlPullParser, attributeSet, theme);
+            } else {
+                drawable = Compatibility.Api21Impl.createFromXmlInner(resources, xmlPullParser, attributeSet, theme);
+            }
+        }
+        if (drawable == null) {
+            throw new XmlPullParserException(xmlPullParser.getPositionDescription() + ITEM_MISSING_DRAWABLE_ERROR);
+        }
+        return this.mState.addStateSet(extractStateSet, drawable, resourceId);
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat, androidx.appcompat.graphics.drawable.DrawableContainerCompat, android.graphics.drawable.Drawable
+    @NonNull
+    public Drawable mutate() {
+        if (!this.mMutated && super.mutate() == this) {
+            this.mState.mutate();
+            this.mMutated = true;
+        }
+        return this;
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat, androidx.appcompat.graphics.drawable.DrawableContainerCompat
+    public AnimatedStateListState cloneConstantState() {
+        return new AnimatedStateListState(this.mState, this, null);
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat, androidx.appcompat.graphics.drawable.DrawableContainerCompat
+    public void clearMutated() {
+        super.clearMutated();
+        this.mMutated = false;
+    }
+
+    public static class AnimatedStateListState extends StateListDrawableCompat.StateListState {
+        private static final long REVERSED_BIT = 4294967296L;
+        private static final long REVERSIBLE_FLAG_BIT = 8589934592L;
+        SparseArrayCompat<Integer> mStateIds;
+        LongSparseArray<Long> mTransitions;
+
+        private static long generateTransitionKey(int i, int i2) {
+            return i2 | (i << 32);
+        }
+
+        public AnimatedStateListState(@Nullable AnimatedStateListState animatedStateListState, @NonNull AnimatedStateListDrawableCompat animatedStateListDrawableCompat, @Nullable Resources resources) {
+            super(animatedStateListState, animatedStateListDrawableCompat, resources);
+            if (animatedStateListState != null) {
+                this.mTransitions = animatedStateListState.mTransitions;
+                this.mStateIds = animatedStateListState.mStateIds;
+            } else {
+                this.mTransitions = new LongSparseArray<>();
+                this.mStateIds = new SparseArrayCompat<>();
+            }
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat.StateListState, androidx.appcompat.graphics.drawable.DrawableContainerCompat.DrawableContainerState
+        public void mutate() {
+            this.mTransitions = this.mTransitions.m34clone();
+            this.mStateIds = this.mStateIds.m35clone();
+        }
+
+        public int addTransition(int i, int i2, @NonNull Drawable drawable, boolean z) {
+            int addChild = super.addChild(drawable);
+            long generateTransitionKey = generateTransitionKey(i, i2);
+            long j = z ? REVERSIBLE_FLAG_BIT : 0L;
+            long j2 = addChild;
+            this.mTransitions.append(generateTransitionKey, Long.valueOf(j2 | j));
+            if (z) {
+                this.mTransitions.append(generateTransitionKey(i2, i), Long.valueOf(REVERSED_BIT | j2 | j));
+            }
+            return addChild;
+        }
+
+        public int addStateSet(@NonNull int[] iArr, @NonNull Drawable drawable, int i) {
+            int addStateSet = super.addStateSet(iArr, drawable);
+            this.mStateIds.put(addStateSet, Integer.valueOf(i));
+            return addStateSet;
+        }
+
+        public int indexOfKeyframe(@NonNull int[] iArr) {
+            int indexOfStateSet = super.indexOfStateSet(iArr);
+            return indexOfStateSet >= 0 ? indexOfStateSet : super.indexOfStateSet(StateSet.WILD_CARD);
+        }
+
+        public int getKeyframeIdAt(int i) {
+            if (i < 0) {
+                return 0;
+            }
+            return this.mStateIds.get(i, 0).intValue();
+        }
+
+        public int indexOfTransition(int i, int i2) {
+            return (int) this.mTransitions.get(generateTransitionKey(i, i2), -1L).longValue();
+        }
+
+        public boolean isTransitionReversed(int i, int i2) {
+            return (this.mTransitions.get(generateTransitionKey(i, i2), -1L).longValue() & REVERSED_BIT) != 0;
+        }
+
+        public boolean transitionHasReversibleFlag(int i, int i2) {
+            return (this.mTransitions.get(generateTransitionKey(i, i2), -1L).longValue() & REVERSIBLE_FLAG_BIT) != 0;
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat.StateListState, android.graphics.drawable.Drawable.ConstantState
+        @NonNull
+        public Drawable newDrawable() {
+            return new AnimatedStateListDrawableCompat(this, null);
+        }
+
+        @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat.StateListState, android.graphics.drawable.Drawable.ConstantState
+        @NonNull
+        public Drawable newDrawable(Resources resources) {
+            return new AnimatedStateListDrawableCompat(this, resources);
+        }
+    }
+
+    @Override // androidx.appcompat.graphics.drawable.StateListDrawableCompat, androidx.appcompat.graphics.drawable.DrawableContainerCompat
+    public void setConstantState(@NonNull DrawableContainerCompat.DrawableContainerState drawableContainerState) {
+        super.setConstantState(drawableContainerState);
+        if (drawableContainerState instanceof AnimatedStateListState) {
+            this.mState = (AnimatedStateListState) drawableContainerState;
+        }
+    }
+
+    public static class FrameInterpolator implements TimeInterpolator {
+        private int[] mFrameTimes;
+        private int mFrames;
+        private int mTotalDuration;
+
+        public int getTotalDuration() {
+            return this.mTotalDuration;
+        }
+
+        public FrameInterpolator(AnimationDrawable animationDrawable, boolean z) {
+            updateFrames(animationDrawable, z);
+        }
+
+        public int updateFrames(AnimationDrawable animationDrawable, boolean z) {
+            int numberOfFrames = animationDrawable.getNumberOfFrames();
+            this.mFrames = numberOfFrames;
+            int[] iArr = this.mFrameTimes;
+            if (iArr == null || iArr.length < numberOfFrames) {
+                this.mFrameTimes = new int[numberOfFrames];
+            }
+            int[] iArr2 = this.mFrameTimes;
+            int i = 0;
+            for (int i2 = 0; i2 < numberOfFrames; i2++) {
+                int duration = animationDrawable.getDuration(z ? (numberOfFrames - i2) - 1 : i2);
+                iArr2[i2] = duration;
+                i += duration;
+            }
+            this.mTotalDuration = i;
+            return i;
+        }
+
+        @Override // android.animation.TimeInterpolator
+        public float getInterpolation(float f) {
+            int i = (int) ((f * this.mTotalDuration) + 0.5f);
+            int i2 = this.mFrames;
+            int[] iArr = this.mFrameTimes;
+            int i3 = 0;
+            while (i3 < i2) {
+                int i4 = iArr[i3];
+                if (i < i4) {
+                    break;
+                }
+                i -= i4;
+                i3++;
+            }
+            return (i3 / i2) + (i3 < i2 ? i / this.mTotalDuration : 0.0f);
+        }
+    }
+}