Java Code Examples for android.animation.Animator#cancel()

private void addIndicator(@DrawableRes int backgroundDrawableId, Animator animator) {
    if (animator.isRunning()) {
        animator.end();
        animator.cancel();
    }

    View Indicator = new View(getContext());
    Indicator.setBackgroundResource(backgroundDrawableId);
    addView(Indicator, mIndicatorWidth, mIndicatorHeight);
    LayoutParams lp = (LayoutParams) Indicator.getLayoutParams();
    lp.leftMargin = mIndicatorMargin;
    lp.rightMargin = mIndicatorMargin;
    Indicator.setLayoutParams(lp);

    animator.setTarget(Indicator);
    animator.start();
}
 

/**
 * This method cancels a transition that is currently running.
 *
 * @hide
 */
protected void cancel() {
    int numAnimators = mCurrentAnimators.size();
    for (int i = numAnimators - 1; i >= 0; i--) {
        Animator animator = mCurrentAnimators.get(i);
        animator.cancel();
    }
    if (mListeners != null && mListeners.size() > 0) {
        ArrayList<TransitionListener> tmpListeners =
                (ArrayList<TransitionListener>) mListeners.clone();
        int numListeners = tmpListeners.size();
        for (int i = 0; i < numListeners; ++i) {
            tmpListeners.get(i).onTransitionCancel(this);
        }
    }
}
 

/**
 * Called when a view is updated to be non-dismissable, if the view was being dismissed before
 * the update this will handle snapping it back into place.
 *
 * @param view the view to snap if necessary.
 * @param animate whether to animate the snap or not.
 * @param targetLeft the target to snap to.
 */
public void snapChildIfNeeded(final View view, boolean animate, float targetLeft) {
    if ((mDragging && mCurrView == view) || mSnappingChild) {
        return;
    }
    boolean needToSnap = false;
    Animator dismissPendingAnim = mDismissPendingMap.get(view);
    if (dismissPendingAnim != null) {
        needToSnap = true;
        dismissPendingAnim.cancel();
    } else if (getTranslation(view) != 0) {
        needToSnap = true;
    }
    if (needToSnap) {
        if (animate) {
            snapChild(view, targetLeft, 0.0f /* velocity */);
        } else {
            snapChildInstantly(view);
        }
    }
}
 

/**
 * Cancels all property animations that are currently running or pending.
 */
public void cancel() {
    if (mAnimatorMap.size() > 0) {
        HashMap<Animator, PropertyBundle> mAnimatorMapCopy =
                (HashMap<Animator, PropertyBundle>)mAnimatorMap.clone();
        Set<Animator> animatorSet = mAnimatorMapCopy.keySet();
        for (Animator runningAnim : animatorSet) {
            runningAnim.cancel();
        }
    }
    mPendingAnimations.clear();
    mPendingSetupAction = null;
    mPendingCleanupAction = null;
    mPendingOnStartAction = null;
    mPendingOnEndAction = null;
    mView.removeCallbacks(mAnimationStarter);
    if (mRTBackend != null) {
        mRTBackend.cancelAll();
    }
}
 

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
private void stopWobble(boolean resetRotation) {
    for (Animator wobbleAnimator : mWobbleAnimators) {
        wobbleAnimator.cancel();
    }
    mWobbleAnimators.clear();
    for (int i = 0; i < getChildCount(); i++) {
        View v = getChildAt(i);
        if (v != null) {
            if (resetRotation) v.setRotation(0);
            v.setTag(R.id.dynamic_grid_wobble_tag, false);
        }
    }
}
 

public static void onDestroyActivity() {
    HashSet<Animator> animators = new HashSet<Animator>(sAnimators.keySet());
    for (Animator a : animators) {
        if (a.isRunning()) {
            a.cancel();
        }
        sAnimators.remove(a);
    }
}
 

private void cancelAnimations() {
    mTmpArray.addAll(mRunningAnimations);
    int size = mTmpArray.size();
    for (int i = 0; i < size; i++) {
        Animator a = mTmpArray.get(i);
        a.cancel();
    }
    mTmpArray.clear();
    mRunningAnimations.clear();
}
 

protected boolean endChangeAnimationIfNecessary(ChangeInfo changeInfo, RecyclerView.ViewHolder item) {
    if (BuildVars.LOGS_ENABLED) {
        FileLog.d("end change if necessary");
    }
    Animator a = animators.remove(item);
    if (a != null) {
        a.cancel();
    }

    boolean oldItem = false;
    if (changeInfo.newHolder == item) {
        changeInfo.newHolder = null;
    } else if (changeInfo.oldHolder == item) {
        changeInfo.oldHolder = null;
        oldItem = true;
    } else {
        return false;
    }
    item.itemView.setAlpha(1);
    if (item.itemView instanceof ChatMessageCell) {
        ((ChatMessageCell) item.itemView).setAnimationOffsetX(0);
        ((ChatMessageCell) item.itemView).getTransitionParams().resetAnimation();
    } else {
        item.itemView.setTranslationX(0);
    }
    item.itemView.setTranslationY(0);
    dispatchChangeFinished(item, oldItem);

    return true;
}
 

/**
 * make animation to start or end when target
 * view was be Visible or Gone or Invisible.
 * make animation to cancel when target view
 * be onDetachedFromWindow.
 *
 * @param animStatus
 */
public void setAnimationStatus(AnimStatus animStatus) {
    if (mAnimators == null) {
        return;
    }
    int count = mAnimators.size();
    for (int i = 0; i < count; i++) {
        Animator animator = mAnimators.get(i);
        boolean isRunning = animator.isRunning();
        switch (animStatus) {
            case START:
                if (!isRunning) {
                    animator.start();
                }
                break;
            case END:
                if (isRunning) {
                    animator.end();
                }
                break;
            case CANCEL:
                if (isRunning) {
                    animator.cancel();
                }
                break;
        }
    }
}
 

public static void onDestroyActivity() {
    HashSet<Animator> animators = new HashSet<Animator>(sAnimators.keySet());
    for (Animator a : animators) {
        if (a.isRunning()) {
            a.cancel();
        }
        sAnimators.remove(a);
    }
}
 

public void cancelAllAnimators() {
    for (int i = 0; i < animatorSparseArray.size(); i++) {
        Animator animator = animatorSparseArray.get(animatorSparseArray.keyAt(i));
        animator.cancel();
    }
    animatorSparseArray.clear();
}
 

private void dismiss() {
    for (Animator animator : mTotalAnimList) {
        animator.cancel();
    }

    if (!mAlphaAnim.isRunning()) {
        mAlphaAnim.start();
    }
}
 

public void cancelAllAnimators() {
    for (int i = 0; i < animatorSparseArray.size(); i++) {
        Animator animator = animatorSparseArray.get(animatorSparseArray.keyAt(i));
        animator.cancel();
    }
    animatorSparseArray.clear();
}
 

@Override
public void cancel() {
    Animator a = mAnimator.get();
    if (a != null) {
        a.cancel();
    }
}
 

private void clearTarget() {
    final AnimatedView view = getTarget();
    final int size = mTuples.size();
    for (int i = 0; i < size; i++) {
        Animator anim = mTuples.get(i).animation;
        if (view.getAnimator() == anim) {
            anim.cancel();
        }
    }
    viewRef = null;
    lastMatch = null;
    runningAnimation = null;
}
 

/**
 * make animation to start or end when target
 * view was be Visible or Gone or Invisible.
 * make animation to cancel when target view
 * be onDetachedFromWindow.
 * @param animStatus
 */
public void setAnimationStatus(AnimStatus animStatus){
    if (mAnimators==null){
        return;
    }
    int count=mAnimators.size();
    for (int i = 0; i < count; i++) {
        Animator animator=mAnimators.get(i);
        boolean isRunning=animator.isRunning();
        switch (animStatus){
            case START:
                if (!isRunning){
                    animator.start();
                }
                break;
            case END:
                if (isRunning){
                    animator.end();
                }
                break;
            case CANCEL:
                if (isRunning){
                    animator.cancel();
                }
                break;
        }
    }
}
 

@Override
public void endAnimation(RecyclerView.ViewHolder item) {
    Animator animator = animators.remove(item);
    if (animator != null) {
        animator.cancel();
    }
    super.endAnimation(item);
    if (BuildVars.LOGS_ENABLED) {
        FileLog.d("end animation");
    }
}
 

/**
 * Utility function, called by animateProperty() and animatePropertyBy(), which handles the
 * details of adding a pending animation and posting the request to start the animation.
 *
 * @param constantName The specifier for the property being animated
 * @param startValue The starting value of the property
 * @param byValue The amount by which the property will change
 */
private void animatePropertyBy(int constantName, float startValue, float byValue) {
    // First, cancel any existing animations on this property
    if (mAnimatorMap.size() > 0) {
        Animator animatorToCancel = null;
        Set<Animator> animatorSet = mAnimatorMap.keySet();
        for (Animator runningAnim : animatorSet) {
            PropertyBundle bundle = mAnimatorMap.get(runningAnim);
            if (bundle.cancel(constantName)) {
                // property was canceled - cancel the animation if it's now empty
                // Note that it's safe to break out here because every new animation
                // on a property will cancel a previous animation on that property, so
                // there can only ever be one such animation running.
                if (bundle.mPropertyMask == NONE) {
                    // the animation is no longer changing anything - cancel it
                    animatorToCancel = runningAnim;
                    break;
                }
            }
        }
        if (animatorToCancel != null) {
            animatorToCancel.cancel();
        }
    }

    NameValuesHolder nameValuePair = new NameValuesHolder(constantName, startValue, byValue);
    mPendingAnimations.add(nameValuePair);
    mView.removeCallbacks(mAnimationStarter);
    mView.postOnAnimation(mAnimationStarter);
}
 

@Override
public void pause(@NonNull Animator animator) {
    animator.cancel();
}
 

/**
 * Called by TransitionManager to play the transition. This calls
 * createAnimators() to set things up and create all of the animations and then
 * runAnimations() to actually start the animations.
 */
void playTransition(ViewGroup sceneRoot) {
    mStartValuesList = new ArrayList<TransitionValues>();
    mEndValuesList = new ArrayList<TransitionValues>();
    matchStartAndEnd(mStartValues, mEndValues);

    ArrayMap<Animator, AnimationInfo> runningAnimators = getRunningAnimators();
    int numOldAnims = runningAnimators.size();
    WindowId windowId = sceneRoot.getWindowId();
    for (int i = numOldAnims - 1; i >= 0; i--) {
        Animator anim = runningAnimators.keyAt(i);
        if (anim != null) {
            AnimationInfo oldInfo = runningAnimators.get(anim);
            if (oldInfo != null && oldInfo.view != null && oldInfo.windowId == windowId) {
                TransitionValues oldValues = oldInfo.values;
                View oldView = oldInfo.view;
                TransitionValues startValues = getTransitionValues(oldView, true);
                TransitionValues endValues = getMatchedTransitionValues(oldView, true);
                if (startValues == null && endValues == null) {
                    endValues = mEndValues.viewValues.get(oldView);
                }
                boolean cancel = (startValues != null || endValues != null) &&
                        oldInfo.transition.isTransitionRequired(oldValues, endValues);
                if (cancel) {
                    if (anim.isRunning() || anim.isStarted()) {
                        if (DBG) {
                            Log.d(LOG_TAG, "Canceling anim " + anim);
                        }
                        anim.cancel();
                    } else {
                        if (DBG) {
                            Log.d(LOG_TAG, "removing anim from info list: " + anim);
                        }
                        runningAnimators.remove(anim);
                    }
                }
            }
        }
    }

    createAnimators(sceneRoot, mStartValues, mEndValues, mStartValuesList, mEndValuesList);
    runAnimators();
}