| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.graphics.drawable; |
| |
| import android.animation.ObjectAnimator; |
| import android.animation.TimeInterpolator; |
| import android.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.content.res.Resources; |
| import android.content.res.Resources.Theme; |
| import android.content.res.TypedArray; |
| import android.os.Build; |
| import android.util.AttributeSet; |
| import android.util.Log; |
| import android.util.LongSparseLongArray; |
| import android.util.SparseIntArray; |
| import android.util.StateSet; |
| |
| import com.android.internal.R; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| |
| import java.io.IOException; |
| |
| /** |
| * Drawable containing a set of Drawable keyframes where the currently displayed |
| * keyframe is chosen based on the current state set. Animations between |
| * keyframes may optionally be defined using transition elements. |
| * <p> |
| * This drawable can be defined in an XML file with the <code> |
| * <animated-selector></code> element. Each keyframe Drawable is defined in a |
| * nested <code><item></code> element. Transitions are defined in a nested |
| * <code><transition></code> element. |
| * |
| * @attr ref android.R.styleable#DrawableStates_state_focused |
| * @attr ref android.R.styleable#DrawableStates_state_window_focused |
| * @attr ref android.R.styleable#DrawableStates_state_enabled |
| * @attr ref android.R.styleable#DrawableStates_state_checkable |
| * @attr ref android.R.styleable#DrawableStates_state_checked |
| * @attr ref android.R.styleable#DrawableStates_state_selected |
| * @attr ref android.R.styleable#DrawableStates_state_activated |
| * @attr ref android.R.styleable#DrawableStates_state_active |
| * @attr ref android.R.styleable#DrawableStates_state_single |
| * @attr ref android.R.styleable#DrawableStates_state_first |
| * @attr ref android.R.styleable#DrawableStates_state_middle |
| * @attr ref android.R.styleable#DrawableStates_state_last |
| * @attr ref android.R.styleable#DrawableStates_state_pressed |
| */ |
| public class AnimatedStateListDrawable extends StateListDrawable { |
| private static final String LOGTAG = AnimatedStateListDrawable.class.getSimpleName(); |
| |
| private static final String ELEMENT_TRANSITION = "transition"; |
| private static final String ELEMENT_ITEM = "item"; |
| |
| @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023) |
| private AnimatedStateListState mState; |
| |
| /** The currently running transition, if any. */ |
| private Transition mTransition; |
| |
| /** Index to be set after the transition ends. */ |
| private int mTransitionToIndex = -1; |
| |
| /** Index away from which we are transitioning. */ |
| private int mTransitionFromIndex = -1; |
| |
| private boolean mMutated; |
| |
| public AnimatedStateListDrawable() { |
| this(null, null); |
| } |
| |
| @Override |
| public boolean setVisible(boolean visible, boolean restart) { |
| final boolean changed = super.setVisible(visible, restart); |
| |
| if (mTransition != null && (changed || restart)) { |
| if (visible) { |
| mTransition.start(); |
| } else { |
| // Ensure we're showing the correct state when visible. |
| jumpToCurrentState(); |
| } |
| } |
| |
| return changed; |
| } |
| |
| /** |
| * Add a new drawable to the set of keyframes. |
| * |
| * @param stateSet An array of resource IDs to associate with the keyframe |
| * @param drawable The drawable to show when in the specified state, may not be null |
| * @param id The unique identifier for the keyframe |
| */ |
| public void addState(@NonNull int[] stateSet, @NonNull Drawable drawable, int id) { |
| if (drawable == null) { |
| throw new IllegalArgumentException("Drawable must not be null"); |
| } |
| |
| mState.addStateSet(stateSet, drawable, id); |
| onStateChange(getState()); |
| } |
| |
| /** |
| * Adds a new transition between keyframes. |
| * |
| * @param fromId Unique identifier of the starting keyframe |
| * @param toId Unique identifier of the ending keyframe |
| * @param transition An {@link Animatable} drawable to use as a transition, may not be null |
| * @param reversible Whether the transition can be reversed |
| */ |
| public <T extends Drawable & Animatable> void addTransition(int fromId, int toId, |
| @NonNull T transition, boolean reversible) { |
| if (transition == null) { |
| throw new IllegalArgumentException("Transition drawable must not be null"); |
| } |
| |
| mState.addTransition(fromId, toId, transition, reversible); |
| } |
| |
| @Override |
| public boolean isStateful() { |
| return true; |
| } |
| |
| @Override |
| protected boolean onStateChange(int[] stateSet) { |
| // If we're not already at the target index, either attempt to find a |
| // valid transition to it or jump directly there. |
| final int targetIndex = mState.indexOfKeyframe(stateSet); |
| boolean changed = targetIndex != getCurrentIndex() |
| && (selectTransition(targetIndex) || selectDrawable(targetIndex)); |
| |
| // We need to propagate the state change to the current drawable, but |
| // we can't call StateListDrawable.onStateChange() without changing the |
| // current drawable. |
| final Drawable current = getCurrent(); |
| if (current != null) { |
| changed |= current.setState(stateSet); |
| } |
| |
| return changed; |
| } |
| |
| private boolean selectTransition(int toIndex) { |
| final int fromIndex; |
| final Transition currentTransition = mTransition; |
| if (currentTransition != null) { |
| if (toIndex == mTransitionToIndex) { |
| // Already animating to that keyframe. |
| return true; |
| } else if (toIndex == mTransitionFromIndex && currentTransition.canReverse()) { |
| // Reverse the current animation. |
| currentTransition.reverse(); |
| mTransitionToIndex = mTransitionFromIndex; |
| mTransitionFromIndex = toIndex; |
| return true; |
| } |
| |
| // Start the next transition from the end of the current one. |
| fromIndex = mTransitionToIndex; |
| |
| // Changing animation, end the current animation. |
| currentTransition.stop(); |
| } else { |
| fromIndex = getCurrentIndex(); |
| } |
| |
| // Reset state. |
| mTransition = null; |
| mTransitionFromIndex = -1; |
| mTransitionToIndex = -1; |
| |
| final AnimatedStateListState state = mState; |
| final int fromId = state.getKeyframeIdAt(fromIndex); |
| final int toId = state.getKeyframeIdAt(toIndex); |
| if (toId == 0 || fromId == 0) { |
| // Missing a keyframe ID. |
| return false; |
| } |
| |
| final int transitionIndex = state.indexOfTransition(fromId, toId); |
| if (transitionIndex < 0) { |
| // Couldn't select a transition. |
| return false; |
| } |
| |
| boolean hasReversibleFlag = state.transitionHasReversibleFlag(fromId, toId); |
| |
| // This may fail if we're already on the transition, but that's okay! |
| selectDrawable(transitionIndex); |
| |
| final Transition transition; |
| final Drawable d = getCurrent(); |
| if (d instanceof AnimationDrawable) { |
| final boolean reversed = state.isTransitionReversed(fromId, toId); |
| |
| transition = new AnimationDrawableTransition((AnimationDrawable) d, |
| reversed, hasReversibleFlag); |
| } else if (d instanceof AnimatedVectorDrawable) { |
| final boolean reversed = state.isTransitionReversed(fromId, toId); |
| |
| transition = new AnimatedVectorDrawableTransition((AnimatedVectorDrawable) d, |
| reversed, hasReversibleFlag); |
| } else if (d instanceof Animatable) { |
| transition = new AnimatableTransition((Animatable) d); |
| } else { |
| // We don't know how to animate this transition. |
| return false; |
| } |
| |
| transition.start(); |
| |
| mTransition = transition; |
| mTransitionFromIndex = fromIndex; |
| mTransitionToIndex = toIndex; |
| return true; |
| } |
| |
| private static abstract class Transition { |
| public abstract void start(); |
| public abstract void stop(); |
| |
| public void reverse() { |
| // Not supported by default. |
| } |
| |
| public boolean canReverse() { |
| return false; |
| } |
| } |
| |
| private static class AnimatableTransition extends Transition { |
| private final Animatable mA; |
| |
| public AnimatableTransition(Animatable a) { |
| mA = a; |
| } |
| |
| @Override |
| public void start() { |
| mA.start(); |
| } |
| |
| @Override |
| public void stop() { |
| mA.stop(); |
| } |
| } |
| |
| |
| private static class AnimationDrawableTransition extends Transition { |
| private final ObjectAnimator mAnim; |
| |
| // Even AnimationDrawable is always reversible technically, but |
| // we should obey the XML's android:reversible flag. |
| private final boolean mHasReversibleFlag; |
| |
| public AnimationDrawableTransition(AnimationDrawable ad, |
| boolean reversed, boolean hasReversibleFlag) { |
| final int frameCount = ad.getNumberOfFrames(); |
| final int fromFrame = reversed ? frameCount - 1 : 0; |
| final int toFrame = reversed ? 0 : frameCount - 1; |
| final FrameInterpolator interp = new FrameInterpolator(ad, reversed); |
| final ObjectAnimator anim = ObjectAnimator.ofInt(ad, "currentIndex", fromFrame, toFrame); |
| anim.setAutoCancel(true); |
| anim.setDuration(interp.getTotalDuration()); |
| anim.setInterpolator(interp); |
| mHasReversibleFlag = hasReversibleFlag; |
| mAnim = anim; |
| } |
| |
| @Override |
| public boolean canReverse() { |
| return mHasReversibleFlag; |
| } |
| |
| @Override |
| public void start() { |
| mAnim.start(); |
| } |
| |
| @Override |
| public void reverse() { |
| mAnim.reverse(); |
| } |
| |
| @Override |
| public void stop() { |
| mAnim.cancel(); |
| } |
| } |
| |
| private static class AnimatedVectorDrawableTransition extends Transition { |
| private final AnimatedVectorDrawable mAvd; |
| |
| // mReversed is indicating the current transition's direction. |
| private final boolean mReversed; |
| |
| // mHasReversibleFlag is indicating whether the whole transition has |
| // reversible flag set to true. |
| // If mHasReversibleFlag is false, then mReversed is always false. |
| private final boolean mHasReversibleFlag; |
| |
| public AnimatedVectorDrawableTransition(AnimatedVectorDrawable avd, |
| boolean reversed, boolean hasReversibleFlag) { |
| mAvd = avd; |
| mReversed = reversed; |
| mHasReversibleFlag = hasReversibleFlag; |
| } |
| |
| @Override |
| public boolean canReverse() { |
| // When the transition's XML says it is not reversible, then we obey |
| // it, even if the AVD itself is reversible. |
| // This will help the single direction transition. |
| return mAvd.canReverse() && mHasReversibleFlag; |
| } |
| |
| @Override |
| public void start() { |
| if (mReversed) { |
| reverse(); |
| } else { |
| mAvd.start(); |
| } |
| } |
| |
| @Override |
| public void reverse() { |
| if (canReverse()) { |
| mAvd.reverse(); |
| } else { |
| Log.w(LOGTAG, "Can't reverse, either the reversible is set to false," |
| + " or the AnimatedVectorDrawable can't reverse"); |
| } |
| } |
| |
| @Override |
| public void stop() { |
| mAvd.stop(); |
| } |
| } |
| |
| |
| @Override |
| public void jumpToCurrentState() { |
| super.jumpToCurrentState(); |
| |
| if (mTransition != null) { |
| mTransition.stop(); |
| mTransition = null; |
| |
| selectDrawable(mTransitionToIndex); |
| mTransitionToIndex = -1; |
| mTransitionFromIndex = -1; |
| } |
| } |
| |
| @Override |
| public void inflate(@NonNull Resources r, @NonNull XmlPullParser parser, |
| @NonNull AttributeSet attrs, @Nullable Theme theme) |
| throws XmlPullParserException, IOException { |
| final TypedArray a = obtainAttributes( |
| r, theme, attrs, R.styleable.AnimatedStateListDrawable); |
| super.inflateWithAttributes(r, parser, a, R.styleable.AnimatedStateListDrawable_visible); |
| updateStateFromTypedArray(a); |
| updateDensity(r); |
| a.recycle(); |
| |
| inflateChildElements(r, parser, attrs, theme); |
| |
| init(); |
| } |
| |
| @Override |
| public void applyTheme(@Nullable Theme theme) { |
| super.applyTheme(theme); |
| |
| final AnimatedStateListState state = mState; |
| if (state == null || state.mAnimThemeAttrs == null) { |
| return; |
| } |
| |
| final TypedArray a = theme.resolveAttributes( |
| state.mAnimThemeAttrs, R.styleable.AnimatedRotateDrawable); |
| updateStateFromTypedArray(a); |
| a.recycle(); |
| |
| init(); |
| } |
| |
| private void updateStateFromTypedArray(TypedArray a) { |
| final AnimatedStateListState state = mState; |
| |
| // Account for any configuration changes. |
| state.mChangingConfigurations |= a.getChangingConfigurations(); |
| |
| // Extract the theme attributes, if any. |
| state.mAnimThemeAttrs = a.extractThemeAttrs(); |
| |
| state.setVariablePadding(a.getBoolean( |
| R.styleable.AnimatedStateListDrawable_variablePadding, state.mVariablePadding)); |
| state.setConstantSize(a.getBoolean( |
| R.styleable.AnimatedStateListDrawable_constantSize, state.mConstantSize)); |
| state.setEnterFadeDuration(a.getInt( |
| R.styleable.AnimatedStateListDrawable_enterFadeDuration, state.mEnterFadeDuration)); |
| state.setExitFadeDuration(a.getInt( |
| R.styleable.AnimatedStateListDrawable_exitFadeDuration, state.mExitFadeDuration)); |
| |
| setDither(a.getBoolean( |
| R.styleable.AnimatedStateListDrawable_dither, state.mDither)); |
| setAutoMirrored(a.getBoolean( |
| R.styleable.AnimatedStateListDrawable_autoMirrored, state.mAutoMirrored)); |
| } |
| |
| private void init() { |
| onStateChange(getState()); |
| } |
| |
| private void inflateChildElements(Resources r, XmlPullParser parser, AttributeSet attrs, |
| Theme theme) throws XmlPullParserException, IOException { |
| int type; |
| |
| final int innerDepth = parser.getDepth() + 1; |
| int depth; |
| while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| && ((depth = parser.getDepth()) >= innerDepth |
| || type != XmlPullParser.END_TAG)) { |
| if (type != XmlPullParser.START_TAG) { |
| continue; |
| } |
| |
| if (depth > innerDepth) { |
| continue; |
| } |
| |
| if (parser.getName().equals(ELEMENT_ITEM)) { |
| parseItem(r, parser, attrs, theme); |
| } else if (parser.getName().equals(ELEMENT_TRANSITION)) { |
| parseTransition(r, parser, attrs, theme); |
| } |
| } |
| } |
| |
| private int parseTransition(@NonNull Resources r, @NonNull XmlPullParser parser, |
| @NonNull AttributeSet attrs, @Nullable Theme theme) |
| throws XmlPullParserException, IOException { |
| // This allows state list drawable item elements to be themed at |
| // inflation time but does NOT make them work for Zygote preload. |
| final TypedArray a = obtainAttributes(r, theme, attrs, |
| R.styleable.AnimatedStateListDrawableTransition); |
| final int fromId = a.getResourceId( |
| R.styleable.AnimatedStateListDrawableTransition_fromId, 0); |
| final int toId = a.getResourceId( |
| R.styleable.AnimatedStateListDrawableTransition_toId, 0); |
| final boolean reversible = a.getBoolean( |
| R.styleable.AnimatedStateListDrawableTransition_reversible, false); |
| Drawable dr = a.getDrawable( |
| R.styleable.AnimatedStateListDrawableTransition_drawable); |
| a.recycle(); |
| |
| // Loading child elements modifies the state of the AttributeSet's |
| // underlying parser, so it needs to happen after obtaining |
| // attributes and extracting states. |
| if (dr == null) { |
| int type; |
| while ((type = parser.next()) == XmlPullParser.TEXT) { |
| } |
| if (type != XmlPullParser.START_TAG) { |
| throw new XmlPullParserException( |
| parser.getPositionDescription() |
| + ": <transition> tag requires a 'drawable' attribute or " |
| + "child tag defining a drawable"); |
| } |
| dr = Drawable.createFromXmlInner(r, parser, attrs, theme); |
| } |
| |
| return mState.addTransition(fromId, toId, dr, reversible); |
| } |
| |
| private int parseItem(@NonNull Resources r, @NonNull XmlPullParser parser, |
| @NonNull AttributeSet attrs, @Nullable Theme theme) |
| throws XmlPullParserException, IOException { |
| // This allows state list drawable item elements to be themed at |
| // inflation time but does NOT make them work for Zygote preload. |
| final TypedArray a = obtainAttributes(r, theme, attrs, |
| R.styleable.AnimatedStateListDrawableItem); |
| final int keyframeId = a.getResourceId(R.styleable.AnimatedStateListDrawableItem_id, 0); |
| Drawable dr = a.getDrawable(R.styleable.AnimatedStateListDrawableItem_drawable); |
| a.recycle(); |
| |
| final int[] states = extractStateSet(attrs); |
| |
| // Loading child elements modifies the state of the AttributeSet's |
| // underlying parser, so it needs to happen after obtaining |
| // attributes and extracting states. |
| if (dr == null) { |
| int type; |
| while ((type = parser.next()) == XmlPullParser.TEXT) { |
| } |
| if (type != XmlPullParser.START_TAG) { |
| throw new XmlPullParserException( |
| parser.getPositionDescription() |
| + ": <item> tag requires a 'drawable' attribute or " |
| + "child tag defining a drawable"); |
| } |
| dr = Drawable.createFromXmlInner(r, parser, attrs, theme); |
| } |
| |
| return mState.addStateSet(states, dr, keyframeId); |
| } |
| |
| @Override |
| public Drawable mutate() { |
| if (!mMutated && super.mutate() == this) { |
| mState.mutate(); |
| mMutated = true; |
| } |
| |
| return this; |
| } |
| |
| @Override |
| AnimatedStateListState cloneConstantState() { |
| return new AnimatedStateListState(mState, this, null); |
| } |
| |
| /** |
| * @hide |
| */ |
| public void clearMutated() { |
| super.clearMutated(); |
| mMutated = false; |
| } |
| |
| static class AnimatedStateListState extends StateListState { |
| // REVERSED_BIT is indicating the current transition's direction. |
| private static final long REVERSED_BIT = 0x100000000l; |
| |
| // REVERSIBLE_FLAG_BIT is indicating whether the whole transition has |
| // reversible flag set to true. |
| private static final long REVERSIBLE_FLAG_BIT = 0x200000000l; |
| |
| int[] mAnimThemeAttrs; |
| |
| @UnsupportedAppUsage |
| LongSparseLongArray mTransitions; |
| @UnsupportedAppUsage |
| SparseIntArray mStateIds; |
| |
| AnimatedStateListState(@Nullable AnimatedStateListState orig, |
| @NonNull AnimatedStateListDrawable owner, @Nullable Resources res) { |
| super(orig, owner, res); |
| |
| if (orig != null) { |
| // Perform a shallow copy and rely on mutate() to deep-copy. |
| mAnimThemeAttrs = orig.mAnimThemeAttrs; |
| mTransitions = orig.mTransitions; |
| mStateIds = orig.mStateIds; |
| } else { |
| mTransitions = new LongSparseLongArray(); |
| mStateIds = new SparseIntArray(); |
| } |
| } |
| |
| void mutate() { |
| mTransitions = mTransitions.clone(); |
| mStateIds = mStateIds.clone(); |
| } |
| |
| int addTransition(int fromId, int toId, @NonNull Drawable anim, boolean reversible) { |
| final int pos = super.addChild(anim); |
| final long keyFromTo = generateTransitionKey(fromId, toId); |
| long reversibleBit = 0; |
| if (reversible) { |
| reversibleBit = REVERSIBLE_FLAG_BIT; |
| } |
| mTransitions.append(keyFromTo, pos | reversibleBit); |
| |
| if (reversible) { |
| final long keyToFrom = generateTransitionKey(toId, fromId); |
| mTransitions.append(keyToFrom, pos | REVERSED_BIT | reversibleBit); |
| } |
| |
| return pos; |
| } |
| |
| int addStateSet(@NonNull int[] stateSet, @NonNull Drawable drawable, int id) { |
| final int index = super.addStateSet(stateSet, drawable); |
| mStateIds.put(index, id); |
| return index; |
| } |
| |
| int indexOfKeyframe(@NonNull int[] stateSet) { |
| final int index = super.indexOfStateSet(stateSet); |
| if (index >= 0) { |
| return index; |
| } |
| |
| return super.indexOfStateSet(StateSet.WILD_CARD); |
| } |
| |
| int getKeyframeIdAt(int index) { |
| return index < 0 ? 0 : mStateIds.get(index, 0); |
| } |
| |
| int indexOfTransition(int fromId, int toId) { |
| final long keyFromTo = generateTransitionKey(fromId, toId); |
| return (int) mTransitions.get(keyFromTo, -1); |
| } |
| |
| boolean isTransitionReversed(int fromId, int toId) { |
| final long keyFromTo = generateTransitionKey(fromId, toId); |
| return (mTransitions.get(keyFromTo, -1) & REVERSED_BIT) != 0; |
| } |
| |
| boolean transitionHasReversibleFlag(int fromId, int toId) { |
| final long keyFromTo = generateTransitionKey(fromId, toId); |
| return (mTransitions.get(keyFromTo, -1) & REVERSIBLE_FLAG_BIT) != 0; |
| } |
| |
| @Override |
| public boolean canApplyTheme() { |
| return mAnimThemeAttrs != null || super.canApplyTheme(); |
| } |
| |
| @Override |
| public Drawable newDrawable() { |
| return new AnimatedStateListDrawable(this, null); |
| } |
| |
| @Override |
| public Drawable newDrawable(Resources res) { |
| return new AnimatedStateListDrawable(this, res); |
| } |
| |
| private static long generateTransitionKey(int fromId, int toId) { |
| return (long) fromId << 32 | toId; |
| } |
| } |
| |
| @Override |
| protected void setConstantState(@NonNull DrawableContainerState state) { |
| super.setConstantState(state); |
| |
| if (state instanceof AnimatedStateListState) { |
| mState = (AnimatedStateListState) state; |
| } |
| } |
| |
| private AnimatedStateListDrawable(@Nullable AnimatedStateListState state, @Nullable Resources res) { |
| super(null); |
| |
| // Every animated state list drawable has its own constant state. |
| final AnimatedStateListState newState = new AnimatedStateListState(state, this, res); |
| setConstantState(newState); |
| onStateChange(getState()); |
| jumpToCurrentState(); |
| } |
| |
| /** |
| * Interpolates between frames with respect to their individual durations. |
| */ |
| private static class FrameInterpolator implements TimeInterpolator { |
| private int[] mFrameTimes; |
| private int mFrames; |
| private int mTotalDuration; |
| |
| public FrameInterpolator(AnimationDrawable d, boolean reversed) { |
| updateFrames(d, reversed); |
| } |
| |
| public int updateFrames(AnimationDrawable d, boolean reversed) { |
| final int N = d.getNumberOfFrames(); |
| mFrames = N; |
| |
| if (mFrameTimes == null || mFrameTimes.length < N) { |
| mFrameTimes = new int[N]; |
| } |
| |
| final int[] frameTimes = mFrameTimes; |
| int totalDuration = 0; |
| for (int i = 0; i < N; i++) { |
| final int duration = d.getDuration(reversed ? N - i - 1 : i); |
| frameTimes[i] = duration; |
| totalDuration += duration; |
| } |
| |
| mTotalDuration = totalDuration; |
| return totalDuration; |
| } |
| |
| public int getTotalDuration() { |
| return mTotalDuration; |
| } |
| |
| @Override |
| public float getInterpolation(float input) { |
| final int elapsed = (int) (input * mTotalDuration + 0.5f); |
| final int N = mFrames; |
| final int[] frameTimes = mFrameTimes; |
| |
| // Find the current frame and remaining time within that frame. |
| int remaining = elapsed; |
| int i = 0; |
| while (i < N && remaining >= frameTimes[i]) { |
| remaining -= frameTimes[i]; |
| i++; |
| } |
| |
| // Remaining time is relative of total duration. |
| final float frameElapsed; |
| if (i < N) { |
| frameElapsed = remaining / (float) mTotalDuration; |
| } else { |
| frameElapsed = 0; |
| } |
| |
| return i / (float) N + frameElapsed; |
| } |
| } |
| } |
