android.animation.ValueAnimator#AnimatorUpdateListener ( )源码实例Demo

@Override
public void call(final Subscriber<? super ValueAnimator> subscriber) {

    final ValueAnimator.AnimatorUpdateListener listener = new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animator) {
            if (!subscriber.isUnsubscribed()) {
                subscriber.onNext(animator);
            }
        }
    };

    animator.addUpdateListener(listener);

    subscriber.add(new OnUnsubscribedCallback() {
        @Override
        protected void onUnsubscribe() {
            animator.removeUpdateListener(listener);
        }
    });
}
 

private ValueAnimator.AnimatorUpdateListener createAnimatorUpdateListener() {
    return new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator valueAnimator) {
            float value = (float) valueAnimator.getAnimatedValue();
            if (valueAnimator == latitudeAnimator) {
                currentLocation.setLatitude(originLocation.getLatitude() + (latitudeDelta * value));
            } else if (valueAnimator == longitudeAnimator) {
                currentLocation.setLongitude(originLocation.getLongitude() + (longitudeDelta * value));
            } else if (valueAnimator == accuracyAnimator) {
                currentLocation.setAccuracy(originLocation.getAccuracy() + (accuracyDelta * value));
            }
            onCurrentLocationUpdated();
        }
    };
}
 

@Override
public void initChart() {

    mAxisRenderers = new ArrayList<>(4);

    mAxisRenderers.add(new AxisRenderer(this, mAxisTop));
    mAxisRenderers.add(new AxisRenderer(this, mAxisBottom));
    mAxisRenderers.add(new AxisRenderer(this, mAxisLeft));
    mAxisRenderers.add(new AxisRenderer(this, mAxisRight));

    mChartAnimator = new ChartAnimator(new ValueAnimator.AnimatorUpdateListener() {
        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            postInvalidate();
        }
    });
}
 

@Override
public ValueAnimator.AnimatorUpdateListener scrollContentWhenFinished(final int spinner) {
    if (mScrollableView != null && spinner != 0) {
        if ((spinner < 0 && ScrollBoundaryHorizontal.canScrollRight(mScrollableView)) || (spinner > 0 && ScrollBoundaryHorizontal.canScrollLeft(mScrollableView))) {
            mLastSpinner = spinner;
            return this;
        }
    }
    return null;
}
 

ValueAnimator createAnimator(float f1, float f2, ValueAnimator.AnimatorUpdateListener l) {
    ValueAnimator a = ValueAnimator.ofFloat(f1, f2);
    a.setDuration(ANIM_DURATION);
    a.setInterpolator(INTERPOLATOR);
    a.addUpdateListener(l);
    return a;
}
 

/**
 * Create an animator update listener to be used to update the drawable to be animated.
 *
 * @param drawable the drawable to create the animator update listener for
 * @return the listener to use
 */
@Nullable
public static ValueAnimator.AnimatorUpdateListener createAnimatorUpdateListener(
    final Drawable drawable) {
  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
    return null;
  }

  if (drawable instanceof AnimatedDrawable2) {
    return AnimatedDrawable2ValueAnimatorHelper.createAnimatorUpdateListener(
        (AnimatedDrawable2) drawable);
  }
  return null;
}
 

public RxAnimatorObservable animationAddUpdateListener(ValueAnimator.AnimatorUpdateListener animatorUpdateListener) {
    if (this.animatorUpdateListeners == null) {
        this.animatorUpdateListeners = new ArrayList<>();
    }
    this.animatorUpdateListeners.add(animatorUpdateListener);
    return this;
}
 

private void createAnimation(ValueAnimator.AnimatorUpdateListener updateListener, Animator.AnimatorListener listener){
    mValueAnimator = ValueAnimator.ofFloat();
    mValueAnimator.setDuration(mBuilder.mAutoSlideDuration);
    mValueAnimator.setInterpolator(mBuilder.mInterpolator);
    mValueAnimator.addUpdateListener(updateListener);
    mValueAnimator.addListener(listener);
}
 

ValueAnimator.AnimatorUpdateListener getUpdateListener() {
    return mUpdateListener;
}
 

private Animator createAnimator(
        final RectangleList rectangleList,
        final float startingOffsetLeft,
        final float startingOffsetRight,
        final List<Animator> cornerAnimators,
        final ValueAnimator.AnimatorUpdateListener updateListener,
        final Runnable onAnimationEnd) {
    final ObjectAnimator rightBoundaryAnimator = ObjectAnimator.ofFloat(
            rectangleList,
            RectangleList.PROPERTY_RIGHT_BOUNDARY,
            startingOffsetRight,
            rectangleList.getTotalWidth());

    final ObjectAnimator leftBoundaryAnimator = ObjectAnimator.ofFloat(
            rectangleList,
            RectangleList.PROPERTY_LEFT_BOUNDARY,
            startingOffsetLeft,
            0);

    rightBoundaryAnimator.setDuration(EXPAND_DURATION);
    leftBoundaryAnimator.setDuration(EXPAND_DURATION);

    rightBoundaryAnimator.addUpdateListener(updateListener);
    leftBoundaryAnimator.addUpdateListener(updateListener);

    rightBoundaryAnimator.setInterpolator(mExpandInterpolator);
    leftBoundaryAnimator.setInterpolator(mExpandInterpolator);

    final AnimatorSet cornerAnimator = new AnimatorSet();
    cornerAnimator.playTogether(cornerAnimators);

    final AnimatorSet boundaryAnimator = new AnimatorSet();
    boundaryAnimator.playTogether(leftBoundaryAnimator, rightBoundaryAnimator);

    final AnimatorSet animatorSet = new AnimatorSet();
    animatorSet.playSequentially(boundaryAnimator, cornerAnimator);

    setUpAnimatorListener(animatorSet, onAnimationEnd);

    return animatorSet;
}
 

public ViewPropertyObjectAnimator removeUpdateListener(ValueAnimator.AnimatorUpdateListener listener) {
    mUpdateListeners.remove(listener);
    return this;
}
 

public CaptureAnimationOverlay(Context context, AttributeSet attrs)
{
    super(context, attrs);
    mPaint.setColor(FLASH_COLOR);
    mFlashAnimInterpolator = new LinearInterpolator();
    mFlashAnimUpdateListener = new ValueAnimator.AnimatorUpdateListener()
    {
        @Override
        public void onAnimationUpdate(ValueAnimator animation)
        {
            float alpha = 255.0f * (Float) animation.getAnimatedValue();
            mPaint.setAlpha((int) alpha);
            invalidate();
        }
    };
    mFlashAnimListener = new Animator.AnimatorListener()
    {
        @Override
        public void onAnimationStart(Animator animation)
        {
            setVisibility(VISIBLE);
        }

        @Override
        public void onAnimationEnd(Animator animation)
        {
            mFlashAnimation = null;
            setVisibility(INVISIBLE);
        }

        @Override
        public void onAnimationCancel(Animator animation)
        {
            // End is always called after cancel.
        }

        @Override
        public void onAnimationRepeat(Animator animation)
        {

        }
    };
}
 

void notifyUpdate() {
  for (ValueAnimator.AnimatorUpdateListener listener : updateListeners) {
    listener.onAnimationUpdate(this);
  }
}
 

public void setAnimatorUpdateListener(final ValueAnimator.AnimatorUpdateListener animatorUpdateListener) {
    mAnimatorUpdateListener = animatorUpdateListener;
}
 

@SuppressWarnings("WeakerAccess") public void addAnimatorUpdateListener(ValueAnimator.AnimatorUpdateListener updateListener) {
  animator.addUpdateListener(updateListener);
}
 

@SuppressWarnings("WeakerAccess") public void removeAnimatorUpdateListener(ValueAnimator.AnimatorUpdateListener updateListener) {
  animator.removeUpdateListener(updateListener);
}
 

public T addUpdateListener(ValueAnimator.AnimatorUpdateListener listener) {
    getValueAnimator().addUpdateListener(listener);
    return self();
}
 

@SuppressWarnings("unused")
public void removeUpdateListener(ValueAnimator.AnimatorUpdateListener updateListener) {
  lottieDrawable.removeAnimatorUpdateListener(updateListener);
}
 

/**
 * Set an {@link android.animation.ValueAnimator} to be
 * attached to the animation.
 *
 * @param listener The listener.
 */
public void setUpdateListener(ValueAnimator.AnimatorUpdateListener listener)
{
    mUpdateListener = listener;
}
 

/**
 * Your should use this to add AnimatorUpdateListener when
 * create animator , otherwise , animator doesn't work when
 * the animation restart .
 *
 * @param updateListener
 */
public void addUpdateListener(ValueAnimator animator, ValueAnimator.AnimatorUpdateListener updateListener) {
    mUpdateListeners.put(animator, updateListener);
}