private void createDefaultIconAnimation() {
ObjectAnimator collapseAnimator =
ObjectAnimator.ofFloat(
mImageToggle,
"rotation",
mLabelsPosition == LABELS_POSITION_LEFT
? OPENED_PLUS_ROTATION_LEFT
: OPENED_PLUS_ROTATION_RIGHT,
CLOSED_PLUS_ROTATION);
ObjectAnimator expandAnimator =
ObjectAnimator.ofFloat(
mImageToggle,
"rotation",
CLOSED_PLUS_ROTATION,
mLabelsPosition == LABELS_POSITION_LEFT
? OPENED_PLUS_ROTATION_LEFT
: OPENED_PLUS_ROTATION_RIGHT);
mOpenAnimatorSet.play(expandAnimator);
mCloseAnimatorSet.play(collapseAnimator);
mOpenAnimatorSet.setInterpolator(mOpenInterpolator);
mCloseAnimatorSet.setInterpolator(mCloseInterpolator);
mOpenAnimatorSet.setDuration(ANIMATION_DURATION);
mCloseAnimatorSet.setDuration(ANIMATION_DURATION);
}
@Override
public void onTextSizeChanged(final TextView textView, float oldSize) {
if (mCurrentState != CalculatorState.INPUT) { // TODO dont animate when showing graph
// Only animate text changes that occur from user input.
return;
}
// Calculate the values needed to perform the scale and translation animations,
// maintaining the same apparent baseline for the displayed text.
final float textScale = oldSize / textView.getTextSize();
final float translationX;
if (android.os.Build.VERSION.SDK_INT >= 17) {
translationX = (1.0f - textScale) * (textView.getWidth() / 2.0f - textView.getPaddingEnd());
} else {
translationX = (1.0f - textScale) * (textView.getWidth() / 2.0f - textView.getPaddingRight());
}
final float translationY =
(1.0f - textScale) * (textView.getHeight() / 2.0f - textView.getPaddingBottom());
final AnimatorSet animatorSet = new AnimatorSet();
animatorSet.playTogether(
ObjectAnimator.ofFloat(textView, View.SCALE_X, textScale, 1.0f),
ObjectAnimator.ofFloat(textView, View.SCALE_Y, textScale, 1.0f),
ObjectAnimator.ofFloat(textView, View.TRANSLATION_X, translationX, 0.0f),
ObjectAnimator.ofFloat(textView, View.TRANSLATION_Y, translationY, 0.0f));
animatorSet.setDuration(getResources().getInteger(android.R.integer.config_mediumAnimTime));
animatorSet.setInterpolator(new AccelerateDecelerateInterpolator());
animatorSet.start();
}
private void animateFadeOutFadeIn(final View src, final View dst) {
if (dst.getVisibility() != View.VISIBLE || dst.getAlpha() != 1f) {
AnimatorSet set = new AnimatorSet();
set.playSequentially(
ObjectAnimator.ofFloat(src, "alpha", 0f), ObjectAnimator.ofFloat(dst, "alpha", 1f));
set.setInterpolator(new LinearInterpolator());
set.addListener(
new AnimatorListener() {
@Override
public void onAnimationStart(Animator animation) {
src.setAlpha(1f);
dst.setAlpha(0f);
src.setVisibility(View.VISIBLE);
dst.setVisibility(View.VISIBLE);
}
@Override
public void onAnimationRepeat(Animator animation) {}
@Override
public void onAnimationEnd(Animator animation) {
src.setVisibility(View.GONE);
}
@Override
public void onAnimationCancel(Animator animation) {}
});
set.setDuration(250);
set.start();
} else {
src.setAlpha(1f);
src.setVisibility(View.GONE);
}
}
private AnimatorSet createAnimationSet() {
List<Animator> animators = new ArrayList<>();
view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
if (!objectAnimations.isEmpty())
for (AnimationParams customAnimation : objectAnimations) {
animators.add(createAnimation(view, customAnimation));
}
if (this.animators != null)
for (Animator animator : this.animators) {
animators.add(animator);
}
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.playTogether(animators);
if (interpolator != null) {
animatorSet.setInterpolator(interpolator);
}
animatorSet.setDuration(duration);
animatorSet.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationCancel(Animator animation) {
super.onAnimationCancel(animation);
view.setLayerType(View.LAYER_TYPE_NONE, null);
}
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
view.setLayerType(View.LAYER_TYPE_NONE, null);
}
});
return animatorSet;
}
private void animateHide() {
bubbleHideAnimator = new AnimatorSet();
this.setPivotX(this.getWidth());
this.setPivotY(this.getHeight());
Animator shrinkerX =
ObjectAnimator.ofFloat(this, SCALE_X, 1f, 0f).setDuration(BUBBLE_ANIMATION_DURATION);
Animator shrinkerY =
ObjectAnimator.ofFloat(this, SCALE_Y, 1f, 0f).setDuration(BUBBLE_ANIMATION_DURATION);
Animator alpha =
ObjectAnimator.ofFloat(this, ALPHA, 1f, 0f).setDuration(BUBBLE_ANIMATION_DURATION);
bubbleHideAnimator.setInterpolator(new AccelerateInterpolator());
bubbleHideAnimator.playTogether(shrinkerX, shrinkerY, alpha);
bubbleHideAnimator.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
FastScrollBubble.this.setVisibility(INVISIBLE);
bubbleHideAnimator = null;
}
@Override
public void onAnimationCancel(Animator animation) {
super.onAnimationCancel(animation);
FastScrollBubble.this.setVisibility(INVISIBLE);
bubbleHideAnimator = null;
}
});
bubbleHideAnimator.start();
}
/** Starts the animation. */
public void start() {
resetAllPaths();
animatorSet.cancel();
animatorSet.setDuration(duration);
animatorSet.setInterpolator(interpolator);
animatorSet.setStartDelay(delay);
animatorSet.start();
}
@Override
public void animate() {
final ViewGroup parentView = (ViewGroup) view.getParent();
final FrameLayout slideOutFrame = new FrameLayout(view.getContext());
final int positionView = parentView.indexOfChild(view);
slideOutFrame.setLayoutParams(view.getLayoutParams());
slideOutFrame.setClipChildren(true);
parentView.removeView(view);
slideOutFrame.addView(view);
parentView.addView(slideOutFrame, positionView);
switch (direction) {
case DIRECTION_LEFT:
slideAnim =
ObjectAnimator.ofFloat(
view, View.TRANSLATION_X, view.getTranslationX() - view.getWidth());
break;
case DIRECTION_RIGHT:
slideAnim =
ObjectAnimator.ofFloat(
view, View.TRANSLATION_X, view.getTranslationX() + view.getWidth());
break;
case DIRECTION_UP:
slideAnim =
ObjectAnimator.ofFloat(
view, View.TRANSLATION_Y, view.getTranslationY() - view.getHeight());
break;
case DIRECTION_DOWN:
slideAnim =
ObjectAnimator.ofFloat(
view, View.TRANSLATION_Y, view.getTranslationY() + view.getHeight());
break;
default:
break;
}
AnimatorSet slideSet = new AnimatorSet();
slideSet.play(slideAnim);
slideSet.setInterpolator(interpolator);
slideSet.setDuration(duration);
slideSet.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
view.setVisibility(View.INVISIBLE);
slideAnim.reverse();
slideOutFrame.removeAllViews();
parentView.removeView(slideOutFrame);
parentView.addView(view, positionView);
if (getListener() != null) {
getListener().onAnimationEnd(SlideOutUnderneathAnimation.this);
}
}
});
slideSet.start();
}
private AnimatorSet buildAnimationSet(int duration, ObjectAnimator... objectAnimators) {
AnimatorSet a = new AnimatorSet();
a.playTogether(objectAnimators);
a.setInterpolator(
AnimationUtils.loadInterpolator(
EventActivity.this, android.R.interpolator.accelerate_decelerate));
a.setDuration(duration);
return a;
}
private void startChildAnimation(View child) {
if (animationEnabled) {
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.playTogether(
ObjectAnimator.ofFloat(child, "alpha", 0.0f, 1.0f),
ObjectAnimator.ofFloat(
child, "translationY", AndroidUtilities.dp(showedFromBotton ? 6 : -6), 0));
animatorSet.setDuration(180);
animatorSet.setInterpolator(decelerateInterpolator);
animatorSet.start();
}
}
@SuppressLint("NewApi")
public void onRevealAnimationProgress(boolean open, float radius, int x, int y) {
if (!open) {
return;
}
int count = Build.VERSION.SDK_INT <= 19 ? 11 : 8;
for (int a = 0; a < count; a++) {
if (views[a].getTag(R.string.AppName) == null) {
if (distCache[a] == 0) {
int buttonX = views[a].getLeft() + views[a].getMeasuredWidth() / 2;
int buttonY = views[a].getTop() + views[a].getMeasuredHeight() / 2;
distCache[a] =
(float) Math.sqrt((x - buttonX) * (x - buttonX) + (y - buttonY) * (y - buttonY));
float vecX = (x - buttonX) / distCache[a];
float vecY = (y - buttonY) / distCache[a];
views[a].setPivotX(views[a].getMeasuredWidth() / 2 + vecX * AndroidUtilities.dp(20));
views[a].setPivotY(views[a].getMeasuredHeight() / 2 + vecY * AndroidUtilities.dp(20));
}
if (distCache[a] > radius + AndroidUtilities.dp(27)) {
continue;
}
views[a].setTag(R.string.AppName, 1);
final ArrayList<Animator> animators = new ArrayList<>();
final ArrayList<Animator> animators2 = new ArrayList<>();
if (a < 8) {
animators.add(ObjectAnimator.ofFloat(views[a], "scaleX", 0.7f, 1.05f));
animators.add(ObjectAnimator.ofFloat(views[a], "scaleY", 0.7f, 1.05f));
animators2.add(ObjectAnimator.ofFloat(views[a], "scaleX", 1.0f));
animators2.add(ObjectAnimator.ofFloat(views[a], "scaleY", 1.0f));
}
if (Build.VERSION.SDK_INT <= 19) {
animators.add(ObjectAnimator.ofFloat(views[a], "alpha", 1.0f));
}
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.playTogether(animators);
animatorSet.setDuration(150);
animatorSet.setInterpolator(decelerateInterpolator);
animatorSet.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.playTogether(animators2);
animatorSet.setDuration(100);
animatorSet.setInterpolator(decelerateInterpolator);
animatorSet.start();
}
});
animatorSet.start();
}
}
}
private void animBottom(View v) {
ObjectAnimator animator_x = ObjectAnimator.ofFloat(v, View.ALPHA, 0f, 1f);
animator_x.setDuration(ANIMATION_DURATION_BASE * 2);
int y = v.getTop();
if (mStart) y += vh.ll_parent.getPaddingTop();
ObjectAnimator animator_y = ObjectAnimator.ofFloat(v, "y", +1400, y);
animator_y.setDuration(ANIMATION_DURATION_BASE);
AnimatorSet set = new AnimatorSet();
set.setInterpolator(new LinearInterpolator());
set.playTogether(animator_x, animator_y);
set.start();
}
@Override
public AnimatorSet createAnimatorSet() {
ViewHelper.setClipChildren(targetView, false);
AnimatorSet rotationSet = new AnimatorSet();
rotationSet.play(
ObjectAnimator.ofFloat(targetView, View.ROTATION, targetView.getRotation() + degrees));
rotationSet.setInterpolator(interpolator);
rotationSet.setDuration(duration);
if (listener != null) {
rotationSet.addListener(listener);
}
return rotationSet;
}
private void animateShow() {
AnimatorSet animatorSet = new AnimatorSet();
this.setPivotX(this.getWidth());
this.setPivotY(this.getHeight());
this.setVisibility(VISIBLE);
Animator growerX =
ObjectAnimator.ofFloat(this, SCALE_X, 0f, 1f).setDuration(BUBBLE_ANIMATION_DURATION);
Animator growerY =
ObjectAnimator.ofFloat(this, SCALE_Y, 0f, 1f).setDuration(BUBBLE_ANIMATION_DURATION);
Animator alpha =
ObjectAnimator.ofFloat(this, ALPHA, 0f, 1f).setDuration(BUBBLE_ANIMATION_DURATION);
animatorSet.setInterpolator(new DecelerateInterpolator());
animatorSet.playTogether(growerX, growerY, alpha);
animatorSet.start();
}
/**
* item的交换动画效果
*
* @param oldPosition
* @param newPosition
*/
private void animateReorder(final int oldPosition, final int newPosition) {
boolean isForward = newPosition > oldPosition;
List<Animator> resultList = new LinkedList<Animator>();
if (isForward) {
for (int pos = oldPosition; pos < newPosition; pos++) {
View view = getChildAt(pos - getFirstVisiblePosition());
System.out.println(pos);
if ((pos + 1) % getNumColumns() == 0) {
resultList.add(
createTranslationAnimations(
view, -view.getWidth() * (getNumColumns() - 1), 0, view.getHeight(), 0));
} else {
resultList.add(createTranslationAnimations(view, view.getWidth(), 0, 0, 0));
}
}
} else {
for (int pos = oldPosition; pos > newPosition; pos--) {
View view = getChildAt(pos - getFirstVisiblePosition());
if ((pos + getNumColumns()) % getNumColumns() == 0) {
resultList.add(
createTranslationAnimations(
view, view.getWidth() * (getNumColumns() - 1), 0, -view.getHeight(), 0));
} else {
resultList.add(createTranslationAnimations(view, -view.getWidth(), 0, 0, 0));
}
}
}
AnimatorSet resultSet = new AnimatorSet();
resultSet.playTogether(resultList);
resultSet.setDuration(300);
resultSet.setInterpolator(new AccelerateDecelerateInterpolator());
resultSet.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
mAnimationEnd = false;
}
@Override
public void onAnimationEnd(Animator animation) {
mAnimationEnd = true;
}
});
resultSet.start();
}
private void startAnim(ImageView v) {
ObjectAnimator scaleX = ObjectAnimator.ofFloat(v, "scaleX", 1f, 1.15f);
ObjectAnimator scaleY = ObjectAnimator.ofFloat(v, "scaleY", 1f, 1.15f);
AnimatorSet animatorSet = new AnimatorSet();
animatorSet.setDuration(3000);
animatorSet.setInterpolator(new DecelerateInterpolator());
animatorSet.play(scaleX).with(scaleY);
animatorSet.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
Intent homeIntent = new Intent(MainActivity.this, HomePageActivity.class);
startActivity(homeIntent);
overridePendingTransition(R.anim.fade_in, R.anim.fade_out);
finish();
}
});
animatorSet.start();
}
public void show() {
if (callback != null) {
callback.onShowStart();
}
ObjectAnimator alphaAnimator = ObjectAnimator.ofFloat(this, View.ALPHA, 0f, 1f);
ObjectAnimator scaleXAnimator = ObjectAnimator.ofFloat(this, View.SCALE_X, 1.8f, 1f);
ObjectAnimator scaleYAnimator = ObjectAnimator.ofFloat(this, View.SCALE_Y, 1.8f, 1f);
showAnimatorSet = new AnimatorSet();
showAnimatorSet.playTogether(alphaAnimator, scaleXAnimator, scaleYAnimator);
showAnimatorSet.setDuration(
getResources().getInteger(R.integer.framework_animation_duration_long));
showAnimatorSet.setStartDelay(
getResources().getInteger(R.integer.framework_animation_delay_short));
showAnimatorSet.setInterpolator(new Back.EaseOut(2));
final View container = this;
showAnimatorSet.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
container.setAlpha(0f);
container.setVisibility(View.VISIBLE);
}
@Override
public void onAnimationEnd(Animator animation) {
new Handler()
.postDelayed(
new Runnable() {
@Override
public void run() {
hide();
}
},
getResources().getInteger(R.integer.framework_animation_duration_long));
}
});
showAnimatorSet.start();
}
private void startAnimator() {
Point startPoint = new Point(getWidth() / 2, RADIUS);
Point endPoint = new Point(getWidth() / 2, getHeight() - RADIUS);
ValueAnimator anim = ValueAnimator.ofObject(new PointEvaluator(), startPoint, endPoint);
anim.addUpdateListener(
new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator animation) {
currentPoint = (Point) animation.getAnimatedValue();
invalidate();
}
});
ObjectAnimator anim2 =
ObjectAnimator.ofObject(this, "color", new ColorEvaluator(), "#0000FF", "#FF0000");
AnimatorSet animset = new AnimatorSet();
animset.play(anim).with(anim2);
animset.setInterpolator(new BounceInterpolator());
animset.setDuration(5000);
animset.start();
}
private Animator switchToStandardInputAnimator() {
final View standard = getChildAt(0);
final View manual = getChildAt(1);
AnimatorSet set = new AnimatorSet();
set.setInterpolator(IN_INTERPOLATOR);
set.setDuration(ANIM_DURATION);
set.addListener(
new Animator.AnimatorListener() {
@Override
public void onAnimationStart(Animator animation) {
manual.setVisibility(VISIBLE);
standard.setVisibility(VISIBLE);
}
@Override
public void onAnimationEnd(Animator animation) {
manual.setVisibility(GONE);
standard.setVisibility(VISIBLE);
}
@Override
public void onAnimationCancel(Animator animation) {
manual.setVisibility(GONE);
standard.setVisibility(VISIBLE);
}
@Override
public void onAnimationRepeat(Animator animation) {}
});
set.playTogether(
ofFloat(manual, "translationY", 0, getHeight()),
ofFloat(manual, "alpha", 1f, 0f),
ofFloat(standard, "scaleX", 0.5f, 1f),
ofFloat(standard, "scaleY", 0.5f, 1f),
ofFloat(standard, "alpha", 0f, 1f));
return set;
}
/**
* Method that create a new frame to be drawn in the specified location
*
* @param r The location relative to the parent layout
* @return v The new view
*/
private View createFrame(Rect r, boolean animate) {
int padding = (int) getResources().getDimension(R.dimen.disposition_frame_padding);
final ImageView v = new ImageView(getContext());
v.setImageResource(R.drawable.ic_camera);
v.setScaleType(ScaleType.CENTER);
// Is locked? Then change the background color
v.setBackgroundColor(
getResources()
.getColor(
mResizeFrame == null
? R.color.disposition_locked_frame_bg_color
: R.color.disposition_frame_bg_color));
RelativeLayout.LayoutParams params =
new RelativeLayout.LayoutParams(r.width() - padding, r.height() - padding);
v.setX(r.left + padding);
v.setY(r.top + padding);
v.setOnLongClickListener(this);
addView(v, params);
// Animate the view
if (animate) {
List<Animator> animators = new ArrayList<Animator>();
animators.add(ObjectAnimator.ofFloat(v, "scaleX", 0.0f, 1.0f));
animators.add(ObjectAnimator.ofFloat(v, "scaleY", 0.0f, 1.0f));
animators.add(ObjectAnimator.ofFloat(v, "alpha", 0.0f, 1.0f));
animators.add(ObjectAnimator.ofFloat(v, "alpha", 0.0f, 1.0f));
AnimatorSet animSet = new AnimatorSet();
animSet.playTogether(animators);
animSet.setDuration(getResources().getInteger(R.integer.disposition_show_anim));
animSet.setInterpolator(new BounceInterpolator());
animSet.setTarget(v);
animSet.start();
}
return v;
}
private void animer(int width) {
valeurHaut.setText("");
valeurBas.setText("");
ViewGroup.LayoutParams params = progressBarHaut.getLayoutParams();
params.width = 0;
progressBarHaut.setLayoutParams(params);
ViewGroup.LayoutParams params2 = progressBarBas.getLayoutParams();
params2.width = 0;
progressBarBas.setLayoutParams(params2);
float largeurMax = barreHaut.getWidth();
float pourcentHaut = vHaut / max;
float pourcentBas = vBas / max;
int largeurHaut = (int) (largeurMax * pourcentHaut);
int largeurtBas = (int) (largeurMax * pourcentBas);
final AnimatorSet anim = new AnimatorSet();
anim.setInterpolator(new AccelerateInterpolator());
anim.setDuration((long) temps);
anim.playTogether(
ValueAnimator.ofObject(
new WidthEvaluator(progressBarHaut, valeurHaut, vHaut), 0, largeurHaut),
ValueAnimator.ofObject(
new WidthEvaluator(progressBarBas, valeurBas, vBas), 0, largeurtBas));
this.postDelayed(
new Runnable() {
@Override
public void run() {
anim.start();
}
},
attente);
}
@Override
public boolean animateChange(
RecyclerView.ViewHolder oldHolder,
RecyclerView.ViewHolder newHolder,
ItemHolderInfo preInfo,
ItemHolderInfo postInfo) {
if (preInfo instanceof DesignerNewsItemHolderInfo
&& ((DesignerNewsItemHolderInfo) preInfo).animateAddToPocket) {
final FeedAdapter.DesignerNewsStoryHolder holder =
(FeedAdapter.DesignerNewsStoryHolder) newHolder;
// setup for anim
holder.itemView.setHasTransientState(true);
((ViewGroup) holder.pocket.getParent().getParent()).setClipChildren(false);
final int initialLeft = holder.pocket.getLeft();
final int initialTop = holder.pocket.getTop();
final int translatedLeft = (holder.itemView.getWidth() - holder.pocket.getWidth()) / 2;
final int translatedTop =
initialTop - ((holder.itemView.getHeight() - holder.pocket.getHeight()) / 2);
final ArcMotion arc = new ArcMotion();
// animate the title & pocket icon up, scale the pocket icon up
Animator titleMoveFadeOut =
ObjectAnimator.ofPropertyValuesHolder(
holder.title,
PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, -(holder.itemView.getHeight() / 5)),
PropertyValuesHolder.ofFloat(View.ALPHA, 0.54f));
Animator pocketMoveUp =
ObjectAnimator.ofFloat(
holder.pocket,
View.TRANSLATION_X,
View.TRANSLATION_Y,
arc.getPath(initialLeft, initialTop, translatedLeft, translatedTop));
Animator pocketScaleUp =
ObjectAnimator.ofPropertyValuesHolder(
holder.pocket,
PropertyValuesHolder.ofFloat(View.SCALE_X, 3f),
PropertyValuesHolder.ofFloat(View.SCALE_Y, 3f));
ObjectAnimator pocketFadeUp = ObjectAnimator.ofInt(holder.pocket, ViewUtils.IMAGE_ALPHA, 255);
AnimatorSet up = new AnimatorSet();
up.playTogether(titleMoveFadeOut, pocketMoveUp, pocketScaleUp, pocketFadeUp);
up.setDuration(300);
up.setInterpolator(
AnimationUtils.loadInterpolator(
holder.itemView.getContext(), android.R.interpolator.fast_out_slow_in));
// animate everything back into place
Animator titleMoveFadeIn =
ObjectAnimator.ofPropertyValuesHolder(
holder.title,
PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, 0f),
PropertyValuesHolder.ofFloat(View.ALPHA, 1f));
Animator pocketMoveDown =
ObjectAnimator.ofFloat(
holder.pocket,
View.TRANSLATION_X,
View.TRANSLATION_Y,
arc.getPath(translatedLeft, translatedTop, 0, 0));
Animator pvhPocketScaleDown =
ObjectAnimator.ofPropertyValuesHolder(
holder.pocket,
PropertyValuesHolder.ofFloat(View.SCALE_X, 1f),
PropertyValuesHolder.ofFloat(View.SCALE_Y, 1f));
ObjectAnimator pocketFadeDown =
ObjectAnimator.ofInt(holder.pocket, ViewUtils.IMAGE_ALPHA, 138);
AnimatorSet down = new AnimatorSet();
down.playTogether(titleMoveFadeIn, pocketMoveDown, pvhPocketScaleDown, pocketFadeDown);
down.setDuration(300);
down.setInterpolator(
AnimationUtils.loadInterpolator(
holder.itemView.getContext(), android.R.interpolator.fast_out_slow_in));
down.setStartDelay(500);
// play it
AnimatorSet upDown = new AnimatorSet();
upDown.playSequentially(up, down);
// clean up
upDown.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
dispatchAnimationStarted(holder);
}
@Override
public void onAnimationEnd(Animator animation) {
((ViewGroup) holder.pocket.getParent().getParent()).setClipChildren(true);
holder.itemView.setHasTransientState(false);
dispatchAnimationFinished(holder);
}
});
upDown.start();
}
return super.animateChange(oldHolder, newHolder, preInfo, postInfo);
}
@Override
public void run() {
long delay = MOVE_DELAY;
if (mContentView == null || mSaverView == null) {
mHandler.removeCallbacks(this);
mHandler.postDelayed(this, delay);
return;
}
final float xrange = mContentView.getWidth() - mSaverView.getWidth();
final float yrange = mContentView.getHeight() - mSaverView.getHeight();
Log.v("xrange: " + xrange + " yrange: " + yrange);
if (xrange == 0 && yrange == 0) {
delay = 500; // back in a split second
} else {
final int nextx = (int) (Math.random() * xrange);
final int nexty = (int) (Math.random() * yrange);
if (mSaverView.getAlpha() == 0f) {
// jump right there
mSaverView.setX(nextx);
mSaverView.setY(nexty);
ObjectAnimator.ofFloat(mSaverView, "alpha", 0f, 1f).setDuration(FADE_TIME).start();
} else {
AnimatorSet s = new AnimatorSet();
Animator xMove = ObjectAnimator.ofFloat(mSaverView, "x", mSaverView.getX(), nextx);
Animator yMove = ObjectAnimator.ofFloat(mSaverView, "y", mSaverView.getY(), nexty);
Animator xShrink = ObjectAnimator.ofFloat(mSaverView, "scaleX", 1f, 0.85f);
Animator xGrow = ObjectAnimator.ofFloat(mSaverView, "scaleX", 0.85f, 1f);
Animator yShrink = ObjectAnimator.ofFloat(mSaverView, "scaleY", 1f, 0.85f);
Animator yGrow = ObjectAnimator.ofFloat(mSaverView, "scaleY", 0.85f, 1f);
AnimatorSet shrink = new AnimatorSet();
shrink.play(xShrink).with(yShrink);
AnimatorSet grow = new AnimatorSet();
grow.play(xGrow).with(yGrow);
Animator fadeout = ObjectAnimator.ofFloat(mSaverView, "alpha", 1f, 0f);
Animator fadein = ObjectAnimator.ofFloat(mSaverView, "alpha", 0f, 1f);
if (SLIDE) {
s.play(xMove).with(yMove);
s.setDuration(SLIDE_TIME);
s.play(shrink.setDuration(SLIDE_TIME / 2));
s.play(grow.setDuration(SLIDE_TIME / 2)).after(shrink);
s.setInterpolator(mSlowStartWithBrakes);
} else {
AccelerateInterpolator accel = new AccelerateInterpolator();
DecelerateInterpolator decel = new DecelerateInterpolator();
shrink.setDuration(FADE_TIME).setInterpolator(accel);
fadeout.setDuration(FADE_TIME).setInterpolator(accel);
grow.setDuration(FADE_TIME).setInterpolator(decel);
fadein.setDuration(FADE_TIME).setInterpolator(decel);
s.play(shrink);
s.play(fadeout);
s.play(xMove.setDuration(0)).after(FADE_TIME);
s.play(yMove.setDuration(0)).after(FADE_TIME);
s.play(fadein).after(FADE_TIME);
s.play(grow).after(FADE_TIME);
}
s.start();
}
long now = System.currentTimeMillis();
long adjust = (now % 60000);
delay =
delay
+ (MOVE_DELAY - adjust) // minute aligned
- (SLIDE ? 0 : FADE_TIME) // start moving before the fade
;
}
mHandler.removeCallbacks(this);
mHandler.postDelayed(this, delay);
}
private void animateClose(ObjectAnimator backgroundAnimator) {
AnimationRect rect = getArguments().getParcelable("rect");
if (rect == null) {
photoView.animate().alpha(0);
backgroundAnimator.start();
return;
}
final Rect startBounds = rect.scaledBitmapRect;
final Rect finalBounds = AnimationUtility.getBitmapRectFromImageView(photoView);
if (finalBounds == null) {
photoView.animate().alpha(0);
backgroundAnimator.start();
return;
}
if (Utility.isDevicePort() != rect.isScreenPortrait) {
photoView.animate().alpha(0);
backgroundAnimator.start();
return;
}
float startScale;
if ((float) finalBounds.width() / finalBounds.height()
> (float) startBounds.width() / startBounds.height()) {
startScale = (float) startBounds.height() / finalBounds.height();
} else {
startScale = (float) startBounds.width() / finalBounds.width();
}
final float startScaleFinal = startScale;
int deltaTop = startBounds.top - finalBounds.top;
int deltaLeft = startBounds.left - finalBounds.left;
photoView.setPivotY((photoView.getHeight() - finalBounds.height()) / 2);
photoView.setPivotX((photoView.getWidth() - finalBounds.width()) / 2);
photoView
.animate()
.translationX(deltaLeft)
.translationY(deltaTop)
.scaleY(startScaleFinal)
.scaleX(startScaleFinal)
.setDuration(ANIMATION_DURATION)
.setInterpolator(new AccelerateDecelerateInterpolator())
.withEndAction(
new Runnable() {
@Override
public void run() {
photoView
.animate()
.alpha(0.0f)
.setDuration(200)
.withEndAction(
new Runnable() {
@Override
public void run() {}
});
}
});
AnimatorSet animationSet = new AnimatorSet();
animationSet.setDuration(ANIMATION_DURATION);
animationSet.setInterpolator(new AccelerateDecelerateInterpolator());
animationSet.playTogether(backgroundAnimator);
animationSet.playTogether(
ObjectAnimator.ofFloat(
photoView, "clipBottom", 0, AnimationRect.getClipBottom(rect, finalBounds)));
animationSet.playTogether(
ObjectAnimator.ofFloat(
photoView, "clipRight", 0, AnimationRect.getClipRight(rect, finalBounds)));
animationSet.playTogether(
ObjectAnimator.ofFloat(
photoView, "clipTop", 0, AnimationRect.getClipTop(rect, finalBounds)));
animationSet.playTogether(
ObjectAnimator.ofFloat(
photoView, "clipLeft", 0, AnimationRect.getClipLeft(rect, finalBounds)));
animationSet.start();
}
@Override
public void setInterpolator(TimeInterpolator value) {
mAnimatorSet.setInterpolator(value);
}
private void zoomImageFromThumb(final View thumbView, int imageResId) {
if (mCurrentAnimator != null) {
mCurrentAnimator.cancel();
}
expandedImageView = (ImageView) rootView.findViewById(R.id.expanded_image);
expandedImageView.setOnTouchListener(
new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
if (detector.onTouchEvent(event)) {
return true;
} else {
return false;
}
}
});
expandedImageView.setImageResource(imageResId);
final Rect startBounds = new Rect();
final Rect finalBounds = new Rect();
final Point globalOffset = new Point();
thumbView.getGlobalVisibleRect(startBounds);
rootView.findViewById(R.id.container).getGlobalVisibleRect(finalBounds, globalOffset);
startBounds.offset(-globalOffset.x, -globalOffset.y);
finalBounds.offset(-globalOffset.x, -globalOffset.y);
float startScale;
if ((float) finalBounds.width() / finalBounds.height()
> (float) startBounds.width() / startBounds.height()) {
startScale = (float) startBounds.height() / finalBounds.height();
float startWidth = startScale * finalBounds.width();
float deltaWidth = (startWidth - startBounds.width()) / 2;
startBounds.left -= deltaWidth;
startBounds.right += deltaWidth;
} else {
startScale = (float) startBounds.height() / finalBounds.height();
float startHeight = startScale * finalBounds.height();
float deltaHeight = (startHeight - startBounds.height()) / 2;
startBounds.top -= deltaHeight;
startBounds.bottom += deltaHeight;
}
thumbView.setAlpha(0f);
expandedImageView.setVisibility(View.VISIBLE);
expandedImageView.setPivotX(0f);
expandedImageView.setPivotY(0f);
AnimatorSet set = new AnimatorSet();
set.play(ObjectAnimator.ofFloat(expandedImageView, View.X, startBounds.left, finalBounds.left))
.with(ObjectAnimator.ofFloat(expandedImageView, View.Y, startBounds.top, finalBounds.top))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_X, startScale, 1f))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_Y, startScale, 1f));
set.setDuration(mShortAnimationDuration);
set.setInterpolator(new DecelerateInterpolator());
set.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
mCurrentAnimator = null;
}
@Override
public void onAnimationCancel(Animator animation) {
mCurrentAnimator = null;
}
});
set.start();
mCurrentAnimator = set;
final float startScaleFinal = startScale;
expandedImageView.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
if (mCurrentAnimator != null) {
mCurrentAnimator.cancel();
}
AnimatorSet set = new AnimatorSet();
set.play(ObjectAnimator.ofFloat(expandedImageView, View.X, startBounds.left))
.with(ObjectAnimator.ofFloat(expandedImageView, View.Y, startBounds.top))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_X, startScaleFinal))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_Y, startScaleFinal));
set.setDuration(mShortAnimationDuration);
set.setInterpolator(new DecelerateInterpolator());
set.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
thumbView.setAlpha(1f);
expandedImageView.setVisibility(View.GONE);
mCurrentAnimator = null;
}
@Override
public void onAnimationCancel(Animator animation) {
thumbView.setAlpha(1f);
expandedImageView.setVisibility(View.GONE);
mCurrentAnimator = null;
}
});
set.start();
mCurrentAnimator = set;
}
});
}
/** 指定光标相对位置 */
private void setBorderParams(final View item) {
cursor.clearAnimation();
cursor.setVisibility(View.VISIBLE);
final RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) item.getLayoutParams();
final int l = params.leftMargin + paddingLeft - boarderLeft;
final int t = params.topMargin + paddingTop - boarderTop;
final int r = l + itemWidth + boarderRight;
final int b = t + itemHeight + boarderBottom;
// 判断动画类型
switch (animationType) {
case ANIM_DEFAULT:
cursor.layout(l, t, r, b);
item.bringToFront();
cursor.bringToFront();
if (scalable) {
scaleToLarge(item);
}
break;
case ANIM_TRASLATE:
ValueAnimator transAnimatorX = ObjectAnimator.ofFloat(cursor, "x", cursor.getLeft(), l);
ValueAnimator transAnimatorY = ObjectAnimator.ofFloat(cursor, "y", cursor.getTop(), t);
cursor.layout(l, t, r, b);
item.bringToFront();
cursor.bringToFront();
if (scalable) {
scaleToLarge(item);
}
if (focusIsOut) {
return;
}
animatorSet = new AnimatorSet();
animatorSet.play(transAnimatorY).with(transAnimatorX);
animatorSet.setDuration(durationTraslate);
animatorSet.setInterpolator(new DecelerateInterpolator(1));
// animatorSet.addListener(new AnimatorListener() {
//
// @Override
// public void onAnimationStart(Animator arg0) {
// }
//
// @Override
// public void onAnimationRepeat(Animator arg0) {
// }
//
// @Override
// public void onAnimationEnd(Animator arg0) {
// cursor.layout(l, t, r, b);
// item.bringToFront();
// cursor.bringToFront();
// if (scalable) {
// scaleToLarge(item);
// }
// }
//
// @Override
// public void onAnimationCancel(Animator arg0) {
// }
// });
animatorSet.start();
break;
}
}
protected void onResult(final String result) {
// Calculate the values needed to perform the scale and translation animations,
// accounting for how the scale will affect the final position of the text.
final float resultScale =
mFormulaEditText.getVariableTextSize(result) / mResultEditText.getTextSize();
final float resultTranslationX =
(1.0f - resultScale)
* (mResultEditText.getWidth() / 2.0f - mResultEditText.getPaddingRight());
// Calculate the height of the formula (without padding)
final float formulaRealHeight =
mFormulaEditText.getHeight()
- mFormulaEditText.getPaddingTop()
- mFormulaEditText.getPaddingBottom();
// Calculate the height of the resized result (without padding)
final float resultRealHeight =
resultScale
* (mResultEditText.getHeight()
- mResultEditText.getPaddingTop()
- mResultEditText.getPaddingBottom());
// Now adjust the result upwards!
final float resultTranslationY =
// Move the result up (so both formula + result heights match)
-mFormulaEditText.getHeight()
// Now switch the result's padding top with the formula's padding top
- resultScale * mResultEditText.getPaddingTop()
+ mFormulaEditText.getPaddingTop()
// But the result centers its text! And it's taller now! So adjust for that centered
// text
+ (formulaRealHeight - resultRealHeight) / 2;
// Move the formula all the way to the top of the screen
final float formulaTranslationY = -mFormulaEditText.getBottom();
// Use a value animator to fade to the final text color over the course of the animation.
final int resultTextColor = mResultEditText.getCurrentTextColor();
final int formulaTextColor = mFormulaEditText.getCurrentTextColor();
final ValueAnimator textColorAnimator =
ValueAnimator.ofObject(new ArgbEvaluator(), resultTextColor, formulaTextColor);
textColorAnimator.addUpdateListener(
new AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
mResultEditText.setTextColor((Integer) valueAnimator.getAnimatedValue());
}
});
mResultEditText.setText(result);
mResultEditText.setPivotX(mResultEditText.getWidth() / 2);
mResultEditText.setPivotY(0f);
final AnimatorSet animatorSet = new AnimatorSet();
animatorSet.playTogether(
textColorAnimator,
ObjectAnimator.ofFloat(mResultEditText, View.SCALE_X, resultScale),
ObjectAnimator.ofFloat(mResultEditText, View.SCALE_Y, resultScale),
ObjectAnimator.ofFloat(mResultEditText, View.TRANSLATION_X, resultTranslationX),
ObjectAnimator.ofFloat(mResultEditText, View.TRANSLATION_Y, resultTranslationY),
ObjectAnimator.ofFloat(mFormulaEditText, View.TRANSLATION_Y, formulaTranslationY));
animatorSet.setDuration(getResources().getInteger(android.R.integer.config_longAnimTime));
animatorSet.setInterpolator(new AccelerateDecelerateInterpolator());
animatorSet.addListener(
new AnimationFinishedListener() {
@Override
public void onAnimationFinished() {
// Reset all of the values modified during the animation.
mResultEditText.setPivotY(mResultEditText.getHeight() / 2);
mResultEditText.setTextColor(resultTextColor);
mResultEditText.setScaleX(1.0f);
mResultEditText.setScaleY(1.0f);
mResultEditText.setTranslationX(0.0f);
mResultEditText.setTranslationY(0.0f);
mFormulaEditText.setTranslationY(0.0f);
// Finally update the formula to use the current result.
mFormulaEditText.setText(result);
setState(CalculatorState.RESULT);
}
});
play(animatorSet);
}
public void showAnimation(View MainView, final View thumbView, Bitmap imageResId) {
requestAnimation = true;
if (ivFullScreen == null) {
mView = MainView;
this.thumbView = thumbView;
this.mResId = imageResId;
return;
}
if (mCurrentAnimator != null) {
mCurrentAnimator.cancel();
}
// Load the high-resolution "zoomed-in" image.
final ImageView expandedImageView = ivFullScreen;
expandedImageView.setImageBitmap(imageResId);
// Calculate the starting and ending bounds for the zoomed-in image. This step
// involves lots of math. Yay, math.
final Rect startBounds = new Rect();
final Rect finalBounds = new Rect();
final Point globalOffset = new Point();
// The start bounds are the global visible rectangle of the thumbnail, and the
// final bounds are the global visible rectangle of the container view. Also
// set the container view's offset as the origin for the bounds, since that's
// the origin for the positioning animation properties (X, Y).
thumbView.getGlobalVisibleRect(startBounds);
MainView.getGlobalVisibleRect(finalBounds, globalOffset);
startBounds.offset(-globalOffset.x, -globalOffset.y);
finalBounds.offset(-globalOffset.x, -globalOffset.y);
// Adjust the start bounds to be the same aspect ratio as the final bounds using the
// "center crop" technique. This prevents undesirable stretching during the animation.
// Also calculate the start scaling factor (the end scaling factor is always 1.0).
float startScale;
if ((float) finalBounds.width() / finalBounds.height()
> (float) startBounds.width() / startBounds.height()) {
// Extend start bounds horizontally
startScale = (float) startBounds.height() / finalBounds.height();
float startWidth = startScale * finalBounds.width();
float deltaWidth = (startWidth - startBounds.width()) / 2;
startBounds.left -= deltaWidth;
startBounds.right += deltaWidth;
} else {
// Extend start bounds vertically
startScale = (float) startBounds.width() / finalBounds.width();
float startHeight = startScale * finalBounds.height();
float deltaHeight = (startHeight - startBounds.height()) / 2;
startBounds.top -= deltaHeight;
startBounds.bottom += deltaHeight;
}
// Hide the thumbnail and show the zoomed-in view. When the animation begins,
// it will position the zoomed-in view in the place of the thumbnail.
thumbView.setAlpha(0f);
expandedImageView.setVisibility(View.VISIBLE);
// Set the pivot point for SCALE_X and SCALE_Y transformations to the top-left corner of
// the zoomed-in view (the default is the center of the view).
expandedImageView.setPivotX(0f);
expandedImageView.setPivotY(0f);
// Construct and run the parallel animation of the four translation and scale properties
// (X, Y, SCALE_X, and SCALE_Y).
AnimatorSet set = new AnimatorSet();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
set.play(
ObjectAnimator.ofFloat(expandedImageView, View.X, startBounds.left, finalBounds.left))
.with(ObjectAnimator.ofFloat(expandedImageView, View.Y, startBounds.top, finalBounds.top))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_X, startScale, 1f))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_Y, startScale, 1f));
}
set.setDuration(mShortAnimationDuration);
set.setInterpolator(new DecelerateInterpolator());
set.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
super.onAnimationStart(animation);
}
@Override
public void onAnimationEnd(Animator animation) {
mCurrentAnimator = null;
}
@Override
public void onAnimationCancel(Animator animation) {
mCurrentAnimator = null;
}
});
set.start();
mCurrentAnimator = set;
// Upon clicking the zoomed-in image, it should zoom back down to the original bounds
// and show the thumbnail instead of the expanded image.
final float startScaleFinal = startScale;
expandedImageView.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View view) {
if (mCurrentAnimator != null) {
mCurrentAnimator.cancel();
}
// Animate the four positioning/sizing properties in parallel, back to their
// original values.
AnimatorSet set = new AnimatorSet();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
set.play(ObjectAnimator.ofFloat(expandedImageView, View.X, startBounds.left))
.with(ObjectAnimator.ofFloat(expandedImageView, View.Y, startBounds.top))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_X, startScaleFinal))
.with(ObjectAnimator.ofFloat(expandedImageView, View.SCALE_Y, startScaleFinal));
}
set.setDuration(mShortAnimationDuration);
set.setInterpolator(new DecelerateInterpolator());
set.addListener(
new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
thumbView.setAlpha(1f);
expandedImageView.setVisibility(View.GONE);
dismiss();
mCurrentAnimator = null;
}
@Override
public void onAnimationCancel(Animator animation) {
thumbView.setAlpha(1f);
expandedImageView.setVisibility(View.GONE);
dismiss();
mCurrentAnimator = null;
}
});
set.start();
mCurrentAnimator = set;
}
});
}
public synchronized void place(View v, Point pt, boolean animate) {
final int i = pt.x;
final int j = pt.y;
final float rnd = frand();
if (v.getTag(TAG_POS) != null) {
for (final Point oc : getOccupied(v)) {
mFreeList.add(oc);
mCells[oc.y * mColumns + oc.x] = null;
}
}
int scale = 1;
if (rnd < PROB_4X) {
if (!(i >= mColumns - 3 || j >= mRows - 3)) {
scale = 4;
}
} else if (rnd < PROB_3X) {
if (!(i >= mColumns - 2 || j >= mRows - 2)) {
scale = 3;
}
} else if (rnd < PROB_2X) {
if (!(i == mColumns - 1 || j == mRows - 1)) {
scale = 2;
}
}
v.setTag(TAG_POS, pt);
v.setTag(TAG_SPAN, scale);
tmpSet.clear();
final Point[] occupied = getOccupied(v);
for (final Point oc : occupied) {
final View squatter = mCells[oc.y * mColumns + oc.x];
if (squatter != null) {
tmpSet.add(squatter);
}
}
for (final View squatter : tmpSet) {
for (final Point sq : getOccupied(squatter)) {
mFreeList.add(sq);
mCells[sq.y * mColumns + sq.x] = null;
}
if (squatter != v) {
squatter.setTag(TAG_POS, null);
if (animate) {
squatter
.animate()
.withLayer()
.scaleX(0.5f)
.scaleY(0.5f)
.alpha(0)
.setDuration(DURATION)
.setInterpolator(new AccelerateInterpolator())
.setListener(
new Animator.AnimatorListener() {
public void onAnimationStart(Animator animator) {}
public void onAnimationEnd(Animator animator) {
removeView(squatter);
}
public void onAnimationCancel(Animator animator) {}
public void onAnimationRepeat(Animator animator) {}
})
.start();
} else {
removeView(squatter);
}
}
}
for (final Point oc : occupied) {
mCells[oc.y * mColumns + oc.x] = v;
mFreeList.remove(oc);
}
final float rot = (float) irand(0, 4) * 90f;
if (animate) {
v.bringToFront();
AnimatorSet set1 = new AnimatorSet();
set1.playTogether(
ObjectAnimator.ofFloat(v, View.SCALE_X, (float) scale),
ObjectAnimator.ofFloat(v, View.SCALE_Y, (float) scale));
set1.setInterpolator(new AnticipateOvershootInterpolator());
set1.setDuration(DURATION);
AnimatorSet set2 = new AnimatorSet();
set2.playTogether(
ObjectAnimator.ofFloat(v, View.ROTATION, rot),
ObjectAnimator.ofFloat(v, View.X, i * mCellSize + (scale - 1) * mCellSize / 2),
ObjectAnimator.ofFloat(v, View.Y, j * mCellSize + (scale - 1) * mCellSize / 2));
set2.setInterpolator(new DecelerateInterpolator());
set2.setDuration(DURATION);
set1.addListener(makeHardwareLayerListener(v));
set1.start();
set2.start();
} else {
v.setX(i * mCellSize + (scale - 1) * mCellSize / 2);
v.setY(j * mCellSize + (scale - 1) * mCellSize / 2);
v.setScaleX((float) scale);
v.setScaleY((float) scale);
v.setRotation(rot);
}
}
public void setIconAnimationCloseInterpolator(Interpolator closeInterpolator) {
mCloseAnimatorSet.setInterpolator(closeInterpolator);
}