package com.android.systemui.qs;
|
|
import android.content.Context;
|
import android.content.res.ColorStateList;
|
import android.content.res.TypedArray;
|
import android.graphics.drawable.AnimatedVectorDrawable;
|
import android.util.AttributeSet;
|
import android.util.Log;
|
import android.view.View;
|
import android.view.ViewGroup;
|
import android.widget.ImageView;
|
|
import com.android.systemui.R;
|
|
import java.util.ArrayList;
|
|
public class PageIndicator extends ViewGroup {
|
|
private static final String TAG = "PageIndicator";
|
private static final boolean DEBUG = false;
|
|
private static final long ANIMATION_DURATION = 250;
|
|
// The size of a single dot in relation to the whole animation.
|
private static final float SINGLE_SCALE = .4f;
|
|
private static final float MINOR_ALPHA = .42f;
|
|
private final ArrayList<Integer> mQueuedPositions = new ArrayList<>();
|
|
private final int mPageIndicatorWidth;
|
private final int mPageIndicatorHeight;
|
private final int mPageDotWidth;
|
|
private int mPosition = -1;
|
private boolean mAnimating;
|
|
public PageIndicator(Context context, AttributeSet attrs) {
|
super(context, attrs);
|
mPageIndicatorWidth =
|
(int) mContext.getResources().getDimension(R.dimen.qs_page_indicator_width);
|
mPageIndicatorHeight =
|
(int) mContext.getResources().getDimension(R.dimen.qs_page_indicator_height);
|
mPageDotWidth = (int) (mPageIndicatorWidth * SINGLE_SCALE);
|
}
|
|
public void setNumPages(int numPages) {
|
setVisibility(numPages > 1 ? View.VISIBLE : View.GONE);
|
if (mAnimating) {
|
Log.w(TAG, "setNumPages during animation");
|
}
|
while (numPages < getChildCount()) {
|
removeViewAt(getChildCount() - 1);
|
}
|
TypedArray array = getContext().obtainStyledAttributes(
|
new int[]{android.R.attr.colorControlActivated});
|
int color = array.getColor(0, 0);
|
array.recycle();
|
while (numPages > getChildCount()) {
|
ImageView v = new ImageView(mContext);
|
v.setImageResource(R.drawable.minor_a_b);
|
v.setImageTintList(ColorStateList.valueOf(color));
|
addView(v, new LayoutParams(mPageIndicatorWidth, mPageIndicatorHeight));
|
}
|
// Refresh state.
|
setIndex(mPosition >> 1);
|
}
|
|
public void setLocation(float location) {
|
int index = (int) location;
|
setContentDescription(getContext().getString(R.string.accessibility_quick_settings_page,
|
(index + 1), getChildCount()));
|
int position = index << 1 | ((location != index) ? 1 : 0);
|
if (DEBUG) Log.d(TAG, "setLocation " + location + " " + index + " " + position);
|
|
int lastPosition = mPosition;
|
if (mQueuedPositions.size() != 0) {
|
lastPosition = mQueuedPositions.get(mQueuedPositions.size() - 1);
|
}
|
if (position == lastPosition) return;
|
if (mAnimating) {
|
if (DEBUG) Log.d(TAG, "Queueing transition to " + Integer.toHexString(position));
|
mQueuedPositions.add(position);
|
return;
|
}
|
|
setPosition(position);
|
}
|
|
private void setPosition(int position) {
|
if (isVisibleToUser() && Math.abs(mPosition - position) == 1) {
|
animate(mPosition, position);
|
} else {
|
if (DEBUG) Log.d(TAG, "Skipping animation " + isVisibleToUser() + " " + mPosition
|
+ " " + position);
|
setIndex(position >> 1);
|
}
|
mPosition = position;
|
}
|
|
private void setIndex(int index) {
|
final int N = getChildCount();
|
for (int i = 0; i < N; i++) {
|
ImageView v = (ImageView) getChildAt(i);
|
// Clear out any animation positioning.
|
v.setTranslationX(0);
|
v.setImageResource(R.drawable.major_a_b);
|
v.setAlpha(getAlpha(i == index));
|
}
|
}
|
|
private void animate(int from, int to) {
|
if (DEBUG) Log.d(TAG, "Animating from " + Integer.toHexString(from) + " to "
|
+ Integer.toHexString(to));
|
int fromIndex = from >> 1;
|
int toIndex = to >> 1;
|
|
// Set the position of everything, then we will manually control the two views involved
|
// in the animation.
|
setIndex(fromIndex);
|
|
boolean fromTransition = (from & 1) != 0;
|
boolean isAState = fromTransition ? from > to : from < to;
|
int firstIndex = Math.min(fromIndex, toIndex);
|
int secondIndex = Math.max(fromIndex, toIndex);
|
if (secondIndex == firstIndex) {
|
secondIndex++;
|
}
|
ImageView first = (ImageView) getChildAt(firstIndex);
|
ImageView second = (ImageView) getChildAt(secondIndex);
|
if (first == null || second == null) {
|
// may happen during reInflation or other weird cases
|
return;
|
}
|
// Lay the two views on top of each other.
|
second.setTranslationX(first.getX() - second.getX());
|
|
playAnimation(first, getTransition(fromTransition, isAState, false));
|
first.setAlpha(getAlpha(false));
|
|
playAnimation(second, getTransition(fromTransition, isAState, true));
|
second.setAlpha(getAlpha(true));
|
|
mAnimating = true;
|
}
|
|
private float getAlpha(boolean isMajor) {
|
return isMajor ? 1 : MINOR_ALPHA;
|
}
|
|
private void playAnimation(ImageView imageView, int res) {
|
final AnimatedVectorDrawable avd = (AnimatedVectorDrawable) getContext().getDrawable(res);
|
imageView.setImageDrawable(avd);
|
avd.forceAnimationOnUI();
|
avd.start();
|
// TODO: Figure out how to user an AVD animation callback instead, which doesn't
|
// seem to be working right now...
|
postDelayed(mAnimationDone, ANIMATION_DURATION);
|
}
|
|
private int getTransition(boolean fromB, boolean isMajorAState, boolean isMajor) {
|
if (isMajor) {
|
if (fromB) {
|
if (isMajorAState) {
|
return R.drawable.major_b_a_animation;
|
} else {
|
return R.drawable.major_b_c_animation;
|
}
|
} else {
|
if (isMajorAState) {
|
return R.drawable.major_a_b_animation;
|
} else {
|
return R.drawable.major_c_b_animation;
|
}
|
}
|
} else {
|
if (fromB) {
|
if (isMajorAState) {
|
return R.drawable.minor_b_c_animation;
|
} else {
|
return R.drawable.minor_b_a_animation;
|
}
|
} else {
|
if (isMajorAState) {
|
return R.drawable.minor_c_b_animation;
|
} else {
|
return R.drawable.minor_a_b_animation;
|
}
|
}
|
}
|
}
|
|
@Override
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
final int N = getChildCount();
|
if (N == 0) {
|
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
|
return;
|
}
|
final int widthChildSpec = MeasureSpec.makeMeasureSpec(mPageIndicatorWidth,
|
MeasureSpec.EXACTLY);
|
final int heightChildSpec = MeasureSpec.makeMeasureSpec(mPageIndicatorHeight,
|
MeasureSpec.EXACTLY);
|
for (int i = 0; i < N; i++) {
|
getChildAt(i).measure(widthChildSpec, heightChildSpec);
|
}
|
int width = (mPageIndicatorWidth - mPageDotWidth) * (N - 1) + mPageDotWidth;
|
setMeasuredDimension(width, mPageIndicatorHeight);
|
}
|
|
@Override
|
protected void onLayout(boolean changed, int l, int t, int r, int b) {
|
final int N = getChildCount();
|
if (N == 0) {
|
return;
|
}
|
for (int i = 0; i < N; i++) {
|
int left = (mPageIndicatorWidth - mPageDotWidth) * i;
|
getChildAt(i).layout(left, 0, mPageIndicatorWidth + left, mPageIndicatorHeight);
|
}
|
}
|
|
private final Runnable mAnimationDone = new Runnable() {
|
@Override
|
public void run() {
|
if (DEBUG) Log.d(TAG, "onAnimationEnd - queued: " + mQueuedPositions.size());
|
mAnimating = false;
|
if (mQueuedPositions.size() != 0) {
|
setPosition(mQueuedPositions.remove(0));
|
}
|
}
|
};
|
}
|
