/*
* Copyright (C) 2016 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 com.android.internal.graphics.drawable;
import android.animation.ValueAnimator;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.res.Resources;
import android.content.res.Resources.Theme;
import android.content.res.TypedArray;
import android.graphics.drawable.Animatable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.DrawableContainer;
import android.util.AttributeSet;
import com.android.internal.R;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
/**
* An internal DrawableContainer class, used to draw different things depending on animation scale.
* i.e: animation scale can be 0 in battery saver mode.
* This class contains 2 drawable, one is animatable, the other is static. When animation scale is
* not 0, the animatable drawable will the drawn. Otherwise, the static drawable will be drawn.
* <p>This class implements Animatable since ProgressBar can pick this up similarly as an
* AnimatedVectorDrawable.
* <p>It can be defined in an XML file with the {@code <AnimationScaleListDrawable>}
* element.
*/
public class AnimationScaleListDrawable extends DrawableContainer implements Animatable {
private static final String TAG = "AnimationScaleListDrawable";
private AnimationScaleListState mAnimationScaleListState;
private boolean mMutated;
public AnimationScaleListDrawable() {
this(null, null);
}
private AnimationScaleListDrawable(@Nullable AnimationScaleListState state,
@Nullable Resources res) {
// Every scale list drawable has its own constant state.
final AnimationScaleListState newState = new AnimationScaleListState(state, this, res);
setConstantState(newState);
onStateChange(getState());
}
/**
* Set the current drawable according to the animation scale. If scale is 0, then pick the
* static drawable, otherwise, pick the animatable drawable.
*/
@Override
protected boolean onStateChange(int[] stateSet) {
final boolean changed = super.onStateChange(stateSet);
int idx = mAnimationScaleListState.getCurrentDrawableIndexBasedOnScale();
return selectDrawable(idx) || changed;
}
@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.AnimationScaleListDrawable);
updateDensity(r);
a.recycle();
inflateChildElements(r, parser, attrs, theme);
onStateChange(getState());
}
/**
* Inflates child elements from XML.
*/
private void inflateChildElements(@NonNull Resources r, @NonNull XmlPullParser parser,
@NonNull AttributeSet attrs, @Nullable Theme theme)
throws XmlPullParserException, IOException {
final AnimationScaleListState state = mAnimationScaleListState;
final int innerDepth = parser.getDepth() + 1;
int type;
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 || !parser.getName().equals("item")) {
continue;
}
// Either pick up the android:drawable attribute.
final TypedArray a = obtainAttributes(r, theme, attrs,
R.styleable.AnimationScaleListDrawableItem);
Drawable dr = a.getDrawable(R.styleable.AnimationScaleListDrawableItem_drawable);
a.recycle();
// Or parse the child element under <item>.
if (dr == null) {
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);
}
state.addDrawable(dr);
}
}
@Override
public Drawable mutate() {
if (!mMutated && super.mutate() == this) {
mAnimationScaleListState.mutate();
mMutated = true;
}
return this;
}
@Override
public void clearMutated() {
super.clearMutated();
mMutated = false;
}
@Override
public void start() {
Drawable dr = getCurrent();
if (dr != null && dr instanceof Animatable) {
((Animatable) dr).start();
}
}
@Override
public void stop() {
Drawable dr = getCurrent();
if (dr != null && dr instanceof Animatable) {
((Animatable) dr).stop();
}
}
@Override
public boolean isRunning() {
boolean result = false;
Drawable dr = getCurrent();
if (dr != null && dr instanceof Animatable) {
result = ((Animatable) dr).isRunning();
}
return result;
}
static class AnimationScaleListState extends DrawableContainerState {
int[] mThemeAttrs = null;
// The index of the last static drawable.
int mStaticDrawableIndex = -1;
// The index of the last animatable drawable.
int mAnimatableDrawableIndex = -1;
AnimationScaleListState(AnimationScaleListState orig, AnimationScaleListDrawable owner,
Resources res) {
super(orig, owner, res);
if (orig != null) {
// Perform a shallow copy and rely on mutate() to deep-copy.
mThemeAttrs = orig.mThemeAttrs;
mStaticDrawableIndex = orig.mStaticDrawableIndex;
mAnimatableDrawableIndex = orig.mAnimatableDrawableIndex;
}
}
void mutate() {
mThemeAttrs = mThemeAttrs != null ? mThemeAttrs.clone() : null;
}
/**
* Add the drawable into the container.
* This class only keep track one animatable drawable, and one static. If there are multiple
* defined in the XML, then pick the last one.
*/
int addDrawable(Drawable drawable) {
final int pos = addChild(drawable);
if (drawable instanceof Animatable) {
mAnimatableDrawableIndex = pos;
} else {
mStaticDrawableIndex = pos;
}
return pos;
}
@Override
public Drawable newDrawable() {
return new AnimationScaleListDrawable(this, null);
}
@Override
public Drawable newDrawable(Resources res) {
return new AnimationScaleListDrawable(this, res);
}
@Override
public boolean canApplyTheme() {
return mThemeAttrs != null || super.canApplyTheme();
}
public int getCurrentDrawableIndexBasedOnScale() {
if (ValueAnimator.getDurationScale() == 0) {
return mStaticDrawableIndex;
}
return mAnimatableDrawableIndex;
}
}
@Override
public void applyTheme(@NonNull Theme theme) {
super.applyTheme(theme);
onStateChange(getState());
}
@Override
protected void setConstantState(@NonNull DrawableContainerState state) {
super.setConstantState(state);
if (state instanceof AnimationScaleListState) {
mAnimationScaleListState = (AnimationScaleListState) state;
}
}
}