java类android.animation.TypeEvaluator的实例源码

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 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;
}

@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);
}