private void setCodeSegment(final TextView codeView, String segment) { if (Build.VERSION.SDK_INT >= 11) { ValueAnimator valueAnimator = new ValueAnimator(); valueAnimator.setObjectValues(0, Integer.parseInt(segment)); valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB) @Override public void onAnimationUpdate(ValueAnimator animation) { int value = (int) animation.getAnimatedValue(); codeView.setText(String.format("%05d", value)); } }); valueAnimator.setEvaluator(new TypeEvaluator<Integer>() { public Integer evaluate(float fraction, Integer startValue, Integer endValue) { return Math.round(startValue + (endValue - startValue) * fraction); } }); valueAnimator.setDuration(1000); valueAnimator.start(); } else { codeView.setText(segment); } }
/** * Returns an animator which animates the source image of the {@link ImageView} with start delay. * * <p>The frame rate is 60 fps. */ public static ObjectAnimator createFrameAnimatorWithDelay(ImageView imageView, int[] frames, long startDelay) { ObjectAnimator animator = ObjectAnimator.ofInt(imageView, "imageResource", frames); // Make it 60 fps. animator.setDuration(frames.length * 1000 / 60); animator.setInterpolator(null); animator.setStartDelay(startDelay); animator.setEvaluator(new TypeEvaluator<Integer>() { @Override public Integer evaluate(float fraction, Integer startValue, Integer endValue) { return startValue; } }); return animator; }
@Test public void objectAnimator_shouldSetTheStartingAndEndingValues() throws Exception { ValueObject object = new ValueObject(); ObjectAnimator animator = ObjectAnimator.ofObject(object, "value", new TypeEvaluator<String>() { @Override public String evaluate(float fraction, String startValue, String endValue) { if (fraction < 0.5) { return startValue; } else { return endValue; } } }, "human", "replicant", "unicorn"); animator.setDuration(2000); animator.start(); assertThat(object.getValue()).isEqualTo("human"); Robolectric.idleMainLooper(1000); assertThat(object.getValue()).isEqualTo("replicant"); Robolectric.idleMainLooper(1000); assertThat(object.getValue()).isEqualTo("unicorn"); }
@VisibleForTesting static ViewPagerAnimator<Integer> ofInt(ViewPager viewPager, Provider<Integer> provider, Property<Integer> property, TypeEvaluator<Integer> evaluator, Interpolator interpolator) { return new ViewPagerAnimator<>(viewPager, provider, property, evaluator, interpolator); }
@VisibleForTesting static ViewPagerAnimator<Integer> ofArgb(ViewPager viewPager, Provider<Integer> provider, Property<Integer> property, TypeEvaluator<Integer> evaluator, Interpolator interpolator) { return new ViewPagerAnimator<>(viewPager, provider, property, evaluator, interpolator); }
@VisibleForTesting static ViewPagerAnimator<Number> ofFloat(ViewPager viewPager, Provider<Number> provider, Property<Number> property, TypeEvaluator<Number> evaluator, Interpolator interpolator) { return new ViewPagerAnimator<>(viewPager, provider, property, evaluator, interpolator); }
public ViewPagerAnimator(@NonNull ViewPager viewPager, @NonNull Provider<V> provider, @NonNull Property<V> property, @NonNull TypeEvaluator<V> evaluator, @NonNull Interpolator interpolator) { setViewPager(viewPager); this.provider = provider; this.property = property; this.evaluator = evaluator; setInterpolator(interpolator); }
static ObjectAnimator createArgbAnimator(View view, String propertyName, int startColor, int endColor) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) { return ObjectAnimator.ofObject(view, propertyName, new TypeEvaluator() { @Override public Object evaluate(float fraction, Object startValue, Object endValue) { int startInt = (Integer) startValue; int startA = (startInt >> 24) & 0xff; int startR = (startInt >> 16) & 0xff; int startG = (startInt >> 8) & 0xff; int startB = startInt & 0xff; int endInt = (Integer) endValue; int endA = (endInt >> 24) & 0xff; int endR = (endInt >> 16) & 0xff; int endG = (endInt >> 8) & 0xff; int endB = endInt & 0xff; return (startA + (int)(fraction * (endA - startA))) << 24 | (startR + (int)(fraction * (endR - startR))) << 16 | (startG + (int)(fraction * (endG - startG))) << 8 | (startB + (int)(fraction * (endB - startB))); } }, startColor, endColor); } else { return ObjectAnimator.ofArgb(view, propertyName, startColor, endColor); } }
@TargetApi(LOLLIPOP) private PropertyValuesHolder getPathValuesHolder(Run run, int dy, int dx) { PropertyValuesHolder propertyValuesHolder; if (IS_LOLLIPOP_OR_ABOVE) { PathMotion pathMotion = new PathMotion() { @Override public Path getPath(float startX, float startY, float endX, float endY) { return ReflowTextAnimatorHelper.getPath(startX, startY, endX, endY); } }; propertyValuesHolder = PropertyValuesHolder.ofObject(SwitchDrawable.TOP_LEFT, null, pathMotion.getPath( run.getStart().left, run.getStart().top, run.getEnd().left - dx, run.getEnd().top - dy)); } else { PointF startPoint = new PointF(run.getStart().left, run.getStart().top); PointF endPoint = new PointF(run.getEnd().left - dx, run.getEnd().top - dy); propertyValuesHolder = PropertyValuesHolder.ofObject(SwitchDrawable.TOP_LEFT, new TypeEvaluator<PointF>() { private final PointF point = new PointF(); @Override public PointF evaluate(float fraction, PointF startValue, PointF endValue) { float x = startValue.x + (endValue.x - startValue.x) * fraction; float y = startValue.y + (endValue.y - startValue.y) * fraction; point.set(x, y); return point; } }, startPoint, endPoint); } return propertyValuesHolder; }
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH) static void animateMarkerToICS(Marker marker, LatLng finalPosition, final LatLngInterpolator latLngInterpolator) { TypeEvaluator<LatLng> typeEvaluator = new TypeEvaluator<LatLng>() { @Override public LatLng evaluate(float fraction, LatLng startValue, LatLng endValue) { return latLngInterpolator.interpolate(fraction, startValue, endValue); } }; Property<Marker, LatLng> property = Property.of(Marker.class, LatLng.class, "position"); ObjectAnimator animator = ObjectAnimator.ofObject(marker, property, typeEvaluator, finalPosition); animator.setDuration(3000); animator.start(); }
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH) public static void animateMarkerToICS(IMarker marker, LatLng finalPosition, final LatLngInterpolator latLngInterpolator, long duration) { TypeEvaluator<LatLng> typeEvaluator = new TypeEvaluator<LatLng>() { @Override public LatLng evaluate(float fraction, LatLng startValue, LatLng endValue) { return latLngInterpolator.interpolate(fraction, startValue, endValue); } }; Property<IMarker, LatLng> property = Property.of(IMarker.class, LatLng.class, "position"); ObjectAnimator animator = ObjectAnimator.ofObject(marker, property, typeEvaluator, finalPosition); animator.setDuration(duration); animator.start(); }
/** * @param anim The animator, must not be null * @param arrayAnimator Incoming typed array for Animator's attributes. * @param arrayObjectAnimator Incoming typed array for Object Animator's * attributes. */ private static void parseAnimatorFromTypeArray(ValueAnimator anim, TypedArray arrayAnimator, TypedArray arrayObjectAnimator) { long duration = arrayAnimator.getInt(R.styleable.Animator_android_duration, 300); long startDelay = arrayAnimator.getInt(R.styleable.Animator_android_startOffset, 0); int valueType = arrayAnimator.getInt(R.styleable.Animator_vc_valueType, 0); TypeEvaluator evaluator = null; // Must be a path animator by the time I reach here if (valueType == VALUE_TYPE_PATH) { evaluator = setupAnimatorForPath(anim, arrayAnimator); } else { throw new IllegalArgumentException("target is not a pathType target"); } anim.setDuration(duration); anim.setStartDelay(startDelay); if (arrayAnimator.hasValue(R.styleable.Animator_android_repeatCount)) { anim.setRepeatCount( arrayAnimator.getInt(R.styleable.Animator_android_repeatCount, 0)); } if (arrayAnimator.hasValue(R.styleable.Animator_android_repeatMode)) { anim.setRepeatMode( arrayAnimator.getInt(R.styleable.Animator_android_repeatMode, ValueAnimator.RESTART)); } if (evaluator != null) { anim.setEvaluator(evaluator); } if (arrayObjectAnimator != null) { setupObjectAnimator(anim, arrayObjectAnimator); } }
/** * Setup the Animator to achieve path morphing. * * @param anim The target Animator which will be updated. * @param arrayAnimator TypedArray for the ValueAnimator. * @return the PathDataEvaluator. */ private static TypeEvaluator setupAnimatorForPath(ValueAnimator anim, TypedArray arrayAnimator) { TypeEvaluator evaluator = null; String fromString = arrayAnimator.getString(R.styleable.Animator_vc_valueFrom); String toString = arrayAnimator.getString(R.styleable.Animator_vc_valueTo); PathParser.PathDataNode[] nodesFrom = PathParser.createNodesFromPathData(fromString); PathParser.PathDataNode[] nodesTo = PathParser.createNodesFromPathData(toString); if (nodesFrom != null) { if (nodesTo != null) { anim.setObjectValues(nodesFrom, nodesTo); if (!PathParser.canMorph(nodesFrom, nodesTo)) { throw new InflateException(arrayAnimator.getPositionDescription() + " Can't morph from " + fromString + " to " + toString); } } else { anim.setObjectValues((Object) nodesFrom); } evaluator = new PathDataEvaluator(PathParser.deepCopyNodes(nodesFrom)); } else if (nodesTo != null) { anim.setObjectValues((Object) nodesTo); evaluator = new PathDataEvaluator(PathParser.deepCopyNodes(nodesTo)); } if (DBG_ANIMATOR_INFLATER && evaluator != null) { Log.v(LOG_TAG, "create a new PathDataEvaluator here"); } return evaluator; }
@Implementation public static ObjectAnimator ofObject(Object target, String propertyName, TypeEvaluator typeEvaluator, Object... values) { ObjectAnimator result = new ObjectAnimator(); result.setTarget(target); result.setPropertyName(propertyName); result.setObjectValues(values); result.setEvaluator(typeEvaluator); getAnimatorMapFor(target).put(propertyName, result); return result; }
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH) public static ObjectAnimator animateMarkerToICS(final MapView map, Marker marker, GeoPoint finalPosition, final GeoPointInterpolator GeoPointInterpolator) { TypeEvaluator<GeoPoint> typeEvaluator = new TypeEvaluator<GeoPoint>() { @Override public GeoPoint evaluate(float fraction, GeoPoint startValue, GeoPoint endValue) { return GeoPointInterpolator.interpolate(fraction, startValue, endValue); } }; Property<Marker, GeoPoint> property = Property.of(Marker.class, GeoPoint.class, "position"); ObjectAnimator animator = ObjectAnimator.ofObject(marker, property, typeEvaluator, finalPosition); animator.setDuration(3000); animator.start(); return animator; }
public RxAnimatorObservable animationEvaluator(TypeEvaluator evaluator) { this.evaluator = evaluator; return this; }
public static ViewPagerAnimator<Integer> ofArgb(ViewPager viewPager, Provider<Integer> provider, Property<Integer> property) { @SuppressWarnings("unchecked") final TypeEvaluator<Integer> evaluator = new ArgbEvaluator(); final Interpolator interpolator = new LinearInterpolator(); return ofArgb(viewPager, provider, property, evaluator, interpolator); }
public ViewPagerAnimator(@NonNull ViewPager viewPager, @NonNull Provider<V> provider, @NonNull Property<V> property, @NonNull TypeEvaluator<V> evaluator) { this(viewPager, provider, property, evaluator, new LinearInterpolator()); }
public void setCustomTypeEvaluator(TypeEvaluator<Float> evaluator) { mCustomTypeEvaluator = evaluator; }
public TypeEvaluator getCustomTypeEvaluator() { return mCustomTypeEvaluator; }
protected final T animate(Property<V, Float> property, float target, TypeEvaluator evaluator) { initValueAnimatorIfNeeded(); AdditiveAnimation animation = createAnimation(property, target); animation.setCustomTypeEvaluator(evaluator); return animate(animation); }
private void setTvViewPosition(final FrameLayout.LayoutParams layoutParams, MarginLayoutParams tvViewFrame, boolean animate) { if (DEBUG) { Log.d(TAG, "setTvViewPosition: w=" + layoutParams.width + " h=" + layoutParams.height + " s=" + layoutParams.getMarginStart() + " t=" + layoutParams.topMargin + " e=" + layoutParams.getMarginEnd() + " b=" + layoutParams.bottomMargin + " animate=" + animate); } MarginLayoutParams oldTvViewFrame = mTvViewFrame; mTvViewLayoutParams = layoutParams; mTvViewFrame = tvViewFrame; if (animate) { initTvAnimatorIfNeeded(); if (mTvViewAnimator.isStarted()) { // Cancel the current animation and start new one. mTvViewAnimator.cancel(); mOldTvViewFrame = mLastAnimatedTvViewFrame; } else { mOldTvViewFrame = oldTvViewFrame; } mTvViewAnimator.setObjectValues(mTvView.getLayoutParams(), layoutParams); mTvViewAnimator.setEvaluator(new TypeEvaluator<FrameLayout.LayoutParams>() { FrameLayout.LayoutParams lp; @Override public FrameLayout.LayoutParams evaluate(float fraction, FrameLayout.LayoutParams startValue, FrameLayout.LayoutParams endValue) { if (lp == null) { lp = new FrameLayout.LayoutParams(0, 0); lp.gravity = startValue.gravity; } interpolateMarginsRelative(lp, startValue, endValue, fraction); return lp; } }); mTvViewAnimator .setInterpolator(isTvViewFullScreen() ? mFastOutLinearIn : mLinearOutSlowIn); mTvViewAnimator.start(); } else { if (mTvViewAnimator != null && mTvViewAnimator.isStarted()) { // Continue the current animation. // layoutParams will be applied when animation ends. return; } // This block is also called when animation ends. if (isTvViewFullScreen()) { // When this layout is for full screen, fix the surface size after layout to make // resize animation smooth. During PIP size change, the multiple messages can be // queued, if we don't remove MSG_SET_LAYOUT_PARAMS. mHandler.removeMessages(MSG_SET_LAYOUT_PARAMS); mHandler.obtainMessage(MSG_SET_LAYOUT_PARAMS, layoutParams).sendToTarget(); } else { mTvView.setLayoutParams(layoutParams); } updatePipView(mTvViewFrame); } }
@SuppressWarnings("unchecked") private static Animator createElevationAnimator(View view, float elevation) { Animator animator = ObjectAnimator.ofObject(view, View.TRANSLATION_Z, (TypeEvaluator) new FloatEvaluator(), -elevation, 0f); animator.setInterpolator(new FastOutSlowInInterpolator()); return animator; }
private void animateProgress() { if (DEBUG) Timber.d("animateProgress"); final int start = 0; final int end = getArguments().getInt(RIGHT_CNT_KEY) * 100 / (getArguments().getInt(RIGHT_CNT_KEY)+getArguments().getInt(WRONG_CNT_KEY)); final int duration = 3000; // in milliseconds ObjectAnimator progressBarAnimation = ObjectAnimator.ofFloat(mProgressBar, "progress", start, end); progressBarAnimation.setDuration(duration); progressBarAnimation.setInterpolator(new DecelerateInterpolator()); ValueAnimator percentageAnimator = new ValueAnimator(); percentageAnimator.setObjectValues(start, end); percentageAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { public void onAnimationUpdate(ValueAnimator animation) { mPercentage.setText(String.format("%d%%", animation.getAnimatedValue())); } }); percentageAnimator.setEvaluator(new TypeEvaluator<Integer>() { public Integer evaluate(float fraction, Integer startValue, Integer endValue) { return Math.round(startValue + (endValue - startValue) * fraction); } }); percentageAnimator.setDuration(duration); PropertyValuesHolder alpha = PropertyValuesHolder.ofFloat(View.ALPHA, 0, 1); PropertyValuesHolder scaleX = PropertyValuesHolder.ofFloat(View.SCALE_X, 0, 1); PropertyValuesHolder scaleY = PropertyValuesHolder.ofFloat(View.SCALE_Y, 0, 1); ObjectAnimator textSummaryAnimator = ObjectAnimator.ofPropertyValuesHolder(mTextSummary, alpha, scaleX, scaleY); textSummaryAnimator.setDuration(duration+2000); // show text summary a bit slower // move from left side off-screen ObjectAnimator wrongCntAnimation = ObjectAnimator.ofFloat(mWrongCnt, "X", -mWrongCnt.getWidth(), mWrongCnt.getLeft()); wrongCntAnimation.setDuration(duration); wrongCntAnimation.setInterpolator(new BounceInterpolator()); // move from right side off-screen int screenWidth = getResources().getDisplayMetrics().widthPixels; ObjectAnimator rightCntAnimation = ObjectAnimator.ofFloat(mRightCnt, "X", screenWidth + mRightCnt.getWidth(), mRightCnt.getLeft()); rightCntAnimation.setDuration(duration); rightCntAnimation.setInterpolator(new BounceInterpolator()); mAnimatorSet = new AnimatorSet(); mAnimatorSet.play(progressBarAnimation) .with(percentageAnimator) .with(textSummaryAnimator) .with(rightCntAnimation) .with(wrongCntAnimation); mAnimatorSet.start(); }
@Implementation public void setEvaluator(TypeEvaluator typeEvaluator) { this.typeEvaluator = typeEvaluator; }
@Implementation public void setEvaluator(TypeEvaluator typeEvaluator) { this.typeEvaluator = typeEvaluator; super.setEvaluator(typeEvaluator); }
private ObjectAnimator createMatrixAnimator(ImageView imageView, TypeEvaluator<Matrix> evaluator, Matrix startMatrix, final Matrix endMatrix) { return ObjectAnimator.ofObject(imageView, ANIMATED_TRANSFORM_PROPERTY, evaluator, startMatrix, endMatrix); }
/** * Old API for {@link #property(float, TypeEvaluator, FloatProperty)}, which should be used instead. * @deprecated Use {@link #property(float, TypeEvaluator, FloatProperty)} instead. */ public T animateProperty(float target, TypeEvaluator evaluator, FloatProperty<V> property) { return property(target, evaluator, property); }