下面列出了android.view.animation.CycleInterpolator#android.view.animation.Animation.AnimationListener 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private void startScaleUpAnimation(AnimationListener listener) {
mHeadViewContainer.setVisibility(View.VISIBLE);
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleAnimation);
}
private void animateOffsetToStartPosition(int from,
AnimationListener listener) {
if (mScale) {
startScaleDownReturnToStartAnimation(from, listener);
} else {
mFrom = from;
mAnimateToStartPosition.reset();
mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mAnimateToStartPosition);
}
resetTargetLayoutDelay(ANIMATE_TO_START_DURATION);
}
private void startScaleDownReturnToStartAnimation(int from,
AnimationListener listener) {
mFrom = from;
mStartingScale = ViewCompat.getScaleX(mHeadViewContainer);
mScaleDownToStartAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
setAnimationProgress(targetScale);
moveToStart(interpolatedTime);
}
};
mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleDownToStartAnimation);
}
@SuppressLint("NewApi")
private void startScaleUpAnimation(AnimationListener listener) {
mCircleView.setVisibility(View.VISIBLE);
if (android.os.Build.VERSION.SDK_INT >= 11) {
// Pre API 11, alpha is used in place of scale up to show the
// progress circle appearing.
// Don't adjust the alpha during appearance otherwise.
mProgress.setAlpha(MAX_ALPHA);
}
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime, Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mScaleAnimation);
}
private void startScaleDownReturnToStartAnimation(int from,
Animation.AnimationListener listener) {
mFrom = from;
if (isAlphaUsedForScale()) {
mStartingScale = mProgress.getAlpha();
} else {
mStartingScale = ViewCompat.getScaleX(mCircleView);
}
mScaleDownToStartAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime, Transformation t) {
float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
setAnimationProgress(targetScale);
moveToStart(interpolatedTime);
}
};
mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mScaleDownToStartAnimation);
}
@SuppressLint("NewApi")
private void startScaleDownReturnToStartAnimation(int from,
AnimationListener listener) {
mFrom = from;
if (isAlphaUsedForScale()) {
mStartingScale = mProgress.getAlpha();
} else {
mStartingScale = ViewCompat.getScaleX(mCircleView);
}
mScaleDownToStartAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime, Transformation t) {
float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
setAnimationProgress(targetScale);
moveToStart(interpolatedTime);
}
};
mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mScaleDownToStartAnimation);
}
private void startScaleUpAnimation(AnimationListener listener) {
mCircleView.setVisibility(View.VISIBLE);
if (android.os.Build.VERSION.SDK_INT >= 11) {
// Pre API 11, alpha is used in place of scale up to show the
// progress circle appearing.
// Don't adjust the alpha during appearance otherwise.
mProgress.setAlpha(MAX_ALPHA);
}
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime, Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mScaleAnimation);
}
private void animateOffsetToStartPosition(int from, AnimationListener listener) {
if (mScale) {
// Scale the item back down
startScaleDownReturnToStartAnimation(from, listener);
} else {
mFrom = from;
mAnimateToStartPosition.reset();
mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mAnimateToStartPosition);
}
}
private void startScaleDownReturnToStartAnimation(int from,
AnimationListener listener) {
mFrom = from;
if (isAlphaUsedForScale()) {
mStartingScale = mProgress.getAlpha();
} else {
mStartingScale = ViewCompat.getScaleX(mCircleView);
}
mScaleDownToStartAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime, Transformation t) {
float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
setAnimationProgress(targetScale);
moveToStart(interpolatedTime);
}
};
mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mScaleDownToStartAnimation);
}
private void startScaleUpAnimation(AnimationListener listener) {
mHeadViewContainer.setVisibility(View.VISIBLE);
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleAnimation);
}
private void animateOffsetToStartPosition(int from,
AnimationListener listener) {
if (mScale) {
startScaleDownReturnToStartAnimation(from, listener);
} else {
mFrom = from;
mAnimateToStartPosition.reset();
mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mAnimateToStartPosition);
}
resetTargetLayoutDelay(ANIMATE_TO_START_DURATION);
}
private void startScaleDownReturnToStartAnimation(int from,
AnimationListener listener) {
mFrom = from;
mStartingScale = ViewCompat.getScaleX(mHeadViewContainer);
mScaleDownToStartAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
setAnimationProgress(targetScale);
moveToStart(interpolatedTime);
}
};
mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleDownToStartAnimation);
}
private void startScaleUpAnimation(AnimationListener listener) {
this.mCircleView.setVisibility(0);
if (VERSION.SDK_INT >= 11) {
this.mProgress.setAlpha(255);
}
this.mScaleAnimation = new Animation() {
public void applyTransformation(float interpolatedTime, Transformation t) {
SwipeRefreshLayout.this.setAnimationProgress(interpolatedTime);
}
};
this.mScaleAnimation.setDuration((long) this.mMediumAnimationDuration);
if (listener != null) {
this.mCircleView.setAnimationListener(listener);
}
this.mCircleView.clearAnimation();
this.mCircleView.startAnimation(this.mScaleAnimation);
}
private void startScaleDownReturnToStartAnimation(int from, AnimationListener listener) {
this.mFrom = from;
if (isAlphaUsedForScale()) {
this.mStartingScale = (float) this.mProgress.getAlpha();
} else {
this.mStartingScale = ViewCompat.getScaleX(this.mCircleView);
}
this.mScaleDownToStartAnimation = new Animation() {
public void applyTransformation(float interpolatedTime, Transformation t) {
SwipeRefreshLayout.this.setAnimationProgress(SwipeRefreshLayout.this.mStartingScale + ((-SwipeRefreshLayout.this.mStartingScale) * interpolatedTime));
SwipeRefreshLayout.this.moveToStart(interpolatedTime);
}
};
this.mScaleDownToStartAnimation.setDuration(150);
if (listener != null) {
this.mCircleView.setAnimationListener(listener);
}
this.mCircleView.clearAnimation();
this.mCircleView.startAnimation(this.mScaleDownToStartAnimation);
}
private void startScaleUpAnimation(AnimationListener listener) {
mHeadViewContainer.setVisibility(View.VISIBLE);
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleAnimation);
}
private void animateOffsetToStartPosition(int from,
AnimationListener listener) {
if (mScale) {
startScaleDownReturnToStartAnimation(from, listener);
} else {
mFrom = from;
mAnimateToStartPosition.reset();
mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mAnimateToStartPosition);
}
resetTargetLayoutDelay(ANIMATE_TO_START_DURATION);
}
private void startScaleDownReturnToStartAnimation(int from,
Animation.AnimationListener listener) {
mFrom = from;
mStartingScale = ViewCompat.getScaleX(mHeadViewContainer);
mScaleDownToStartAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
float targetScale = (mStartingScale + (-mStartingScale * interpolatedTime));
setAnimationProgress(targetScale);
moveToStart(interpolatedTime);
}
};
mScaleDownToStartAnimation.setDuration(SCALE_DOWN_DURATION);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleDownToStartAnimation);
}
private void startScaleUpAnimation(AnimationListener listener) {
mCircleView.setVisibility(View.VISIBLE);
if (android.os.Build.VERSION.SDK_INT >= 11) {
// Pre API 11, alpha is used in place of scale up to show the
// progress circle appearing.
// Don't adjust the alpha during appearance otherwise.
mProgress.setAlpha(MAX_ALPHA);
}
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime, Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mScaleAnimation);
}
private void animateOffsetToStartPosition(int from, AnimationListener listener) {
if (mScale) {
// Scale the item back down
startScaleDownReturnToStartAnimation(from, listener);
} else {
mFrom = from;
mAnimateToStartPosition.reset();
mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mCircleView.setAnimationListener(listener);
}
mCircleView.clearAnimation();
mCircleView.startAnimation(mAnimateToStartPosition);
}
}
private void startScaleDownAnimation(AnimationListener listener) {
mScaleDownAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
setAnimationProgress(1 - interpolatedTime);
}
};
mScaleDownAnimation.setDuration(SCALE_DOWN_DURATION);
mHeadViewContainer.setAnimationListener(listener);
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleDownAnimation);
}
private void animateOffsetToCorrectPosition(int from,
AnimationListener listener) {
mFrom = from;
mAnimateToCorrectPosition.reset();
mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION);
mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mAnimateToCorrectPosition);
}
/**
* 获取一个旋转动画
* @param fromDegrees 开始角度
* @param toDegrees 结束角度
* @param durationMillis 动画持续时间
* @param animationListener 动画监听器
* @return 一个旋转动画
*/
public static RotateAnimation getRotateAnimation(final float fromDegrees, final float toDegrees, final long durationMillis,
final AnimationListener animationListener) {
RotateAnimation rotateAnimation = new RotateAnimation(fromDegrees, toDegrees);
rotateAnimation.setDuration(durationMillis);
if (animationListener != null) {
rotateAnimation.setAnimationListener(animationListener);
}
return rotateAnimation;
}
/**
* 获取一个透明度渐变动画
* @param fromAlpha 开始时的透明度
* @param toAlpha 结束时的透明度
* @param durationMillis 动画持续时间
* @param animationListener 动画监听器
* @return 一个透明度渐变动画
*/
public static AlphaAnimation getAlphaAnimation(final float fromAlpha, final float toAlpha, final long durationMillis,
final AnimationListener animationListener) {
AlphaAnimation alphaAnimation = new AlphaAnimation(fromAlpha, toAlpha);
alphaAnimation.setDuration(durationMillis);
if (animationListener != null) {
alphaAnimation.setAnimationListener(animationListener);
}
return alphaAnimation;
}
/**
* 获取一个中心点缩放动画
* @param fromX 动画开始前在 X 坐标
* @param toX 动画结束后在 X 坐标
* @param fromY 动画开始前在 Y 坐标
* @param toY 动画结束后在 Y 坐标
* @param durationMillis 动画持续时间
* @param animationListener 动画监听器
* @return 一个中心点缩放动画
*/
public static ScaleAnimation getScaleAnimationCenter(final float fromX, final float toX, final float fromY, final float toY,
final long durationMillis, final AnimationListener animationListener) {
ScaleAnimation scaleAnimation = new ScaleAnimation(fromX, toX, fromY, toY,
ScaleAnimation.RELATIVE_TO_SELF, 0.5f,
ScaleAnimation.RELATIVE_TO_SELF, 0.5f);
scaleAnimation.setDuration(durationMillis);
if (animationListener != null) {
scaleAnimation.setAnimationListener(animationListener);
}
return scaleAnimation;
}
/**
* 获取一个缩小动画
* @param durationMillis 动画持续时间
* @param animationListener 动画监听器
* @return 一个缩小动画
*/
public static ScaleAnimation getLessenScaleAnimation(final long durationMillis, final AnimationListener animationListener) {
ScaleAnimation scaleAnimation = new ScaleAnimation(1.0f, 0.0f, 1.0f, 0.0f,
ScaleAnimation.RELATIVE_TO_SELF, ScaleAnimation.RELATIVE_TO_SELF);
scaleAnimation.setDuration(durationMillis);
if (animationListener != null) {
scaleAnimation.setAnimationListener(animationListener);
}
return scaleAnimation;
}
/**
* 获取一个放大动画
* @param durationMillis 动画持续时间
* @param animationListener 动画监听器
* @return 一个放大动画
*/
public static ScaleAnimation getAmplificationAnimation(final long durationMillis, final AnimationListener animationListener) {
ScaleAnimation scaleAnimation = new ScaleAnimation(0.0f, 1.0f, 0.0f, 1.0f,
ScaleAnimation.RELATIVE_TO_SELF, ScaleAnimation.RELATIVE_TO_SELF);
scaleAnimation.setDuration(durationMillis);
if (animationListener != null) {
scaleAnimation.setAnimationListener(animationListener);
}
return scaleAnimation;
}
void startScaleUpAnimation(AnimationListener listener) {
mScaleAnimation = new Animation() {
@Override
public void applyTransformation(float interpolatedTime,
Transformation t) {
setAnimationProgress(interpolatedTime);
}
};
mScaleAnimation.setDuration(mMediumAnimationDuration);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mScaleAnimation);
}
void animateOffsetToCorrectPosition(int from, AnimationListener listener) {
mFrom = from;
mAnimateToCorrectPosition.reset();
mAnimateToCorrectPosition.setDuration(ANIMATE_TO_TRIGGER_DURATION);
mAnimateToCorrectPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mAnimateToCorrectPosition);
}
void animateOffsetToStartPosition(int from, AnimationListener listener) {
mFrom = from;
mAnimateToStartPosition.reset();
mAnimateToStartPosition.setDuration(ANIMATE_TO_START_DURATION);
mAnimateToStartPosition.setInterpolator(mDecelerateInterpolator);
if (listener != null) {
mHeadViewContainer.setAnimationListener(listener);
}
mHeadViewContainer.clearAnimation();
mHeadViewContainer.startAnimation(mAnimateToStartPosition);
resetTargetLayoutDelay(ANIMATE_TO_START_DURATION);
}
private void animateOffsetToStartPosition(int from, AnimationListener listener) {
this.mFrom = from;
this.mAnimateToStartPosition.reset();
this.mAnimateToStartPosition.setDuration((long) this.mAnimationDuration);
this.mAnimateToStartPosition.setAnimationListener(listener);
this.mAnimateToStartPosition.setInterpolator(this.mDecelerateInterpolator);
this.mTarget.startAnimation(this.mAnimateToStartPosition);
}