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

public void revealOff() {
    if (binding.mapListContainer.getVisibility() != VISIBLE) return;

    View container = binding.mapListContainer;
    Animator animator = ViewAnimationUtils.createCircularReveal(
            container,
            getRevealCenterX(container),
            container.getTop(),
            (float) Math.hypot(container.getWidth(), container.getHeight()),
            0);
    animator.setInterpolator(INTERPOLATOR);
    animator.setDuration(getResources().getInteger(R.integer.view_reveal_mills));
    animator.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationEnd(Animator animation) {
            binding.mapListContainer.setVisibility(INVISIBLE);
            if (onVisibilityChangeListener != null) {
                onVisibilityChangeListener.onChange();
            }
        }
    });

    animator.start();
}
 

private void hideHint(final View view) {
    view.setPivotX(0);
    view.setPivotY(view.getHeight());

    Animator iconAnim = ObjectAnimator.ofPropertyValuesHolder(view,
            PropertyValuesHolder.ofFloat(View.ALPHA, 1f, 0f),
            PropertyValuesHolder.ofFloat(View.SCALE_Y, 1f, 0f));
    iconAnim.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationEnd(Animator animation) {
            super.onAnimationEnd(animation);
            view.setVisibility(View.INVISIBLE);
        }
    });
    iconAnim.start();
}
 

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

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
void exitReveal(final View myView) {
    // previously visible view
    //final View myView = findViewById(R.id.my_view);

    // get the center for the clipping circle
    int cx = myView.getMeasuredWidth() / 2;
    int cy = myView.getMeasuredHeight() / 2;

    // get the initial radius for the clipping circle
    int initialRadius = myView.getWidth() / 2;

    // create the animation (the final radius is zero)
    Animator anim =
            ViewAnimationUtils.createCircularReveal(myView, cx, cy, initialRadius, 0);

    // make the view invisible when the animation is done
    anim.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationEnd(Animator animation) {
            super.onAnimationEnd(animation);
            myView.setVisibility(View.INVISIBLE);
            horizontalRecyclerview.setVisibility(View.VISIBLE);
        }
    });

    // start the animation
    anim.start();
}
 

/**
 * 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 createCircularReveal(View view, int cx, int cy, int radius){
        if (Build.VERSION.SDK_INT < 21){
            animateSetViewVisibilityVisible(view);
            return;
        }else {
            view.setVisibility(View.VISIBLE);
            //Clear traces from animateSetViewVisibility*
            if (Build.VERSION.SDK_INT >= 12) {
                view.setScaleY(1);
                view.setScaleX(1);
            }
            // get the center for the clipping circle

// get the final radius for the clipping circle

            Log.e("ViewUtils", "finalRadius = " + radius);

// create the animator for this view (the start radius is zero)
            try {

                Animator anim =
                        ViewAnimationUtils.createCircularReveal(view, cx, cy, 0, radius);
// make the view visible and start the animation
                anim.start();
            }catch (IllegalStateException ex){
                ex.printStackTrace();
                view.setVisibility(View.VISIBLE);
            }
        }
    }
 

private void showTop(View view) {
    view.setVisibility(View.VISIBLE);
    Animator iconAnim = ObjectAnimator.ofPropertyValuesHolder(view,
            PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, -view.getHeight(), 0f));
    iconAnim.setDuration(VIEW_ANIMATION);
    iconAnim.start();


}
 

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

public void onAnimationEnd(Animator animator)
{
    StatisticFragment.o(b).setMode(StatisticFragment.j(b));
    StatisticFragment.p(b).setMode(StatisticFragment.j(b));
    Animator animator1 = StatisticFragment.b(b).animRefresh();
    animator1.setDuration(a / 2L);
    animator1.setInterpolator(new DecelerateInterpolator(1.5F));
    animator1.start();
}
 

/**
 * {@inheritDoc}
 */
@Override
public void start() {

    if (isStarted()) {
        return;
    }

    for (Animator animator : mAnimators) {
        animator.start();
    }
    invalidateSelf();
}
 

/**
 * Sets a number to display.
 * @param animate Whether it should smoothly animate to the number.
 */
public void setNumber(int number, boolean animate) {
    if (mLastRollAnimator != null) mLastRollAnimator.cancel();

    if (animate) {
        Animator rollAnimator = ObjectAnimator.ofFloat(this, NUMBER_PROPERTY, number);
        rollAnimator.setInterpolator(BakedBezierInterpolator.TRANSFORM_CURVE);
        rollAnimator.start();
        mLastRollAnimator = rollAnimator;
    } else {
        setNumberRoll(number);
    }
}
 

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

void startAnimation(String ref, String animation, String callBack) {
  WXComponent component = mRegistry.get(ref);
  if (component == null || component.getRealView() == null) {
    return;
  } else {
    try {
      WXAnimationBean animationBean = WXAnimationModule.parseAnimation(animation, component.getRealView().getLayoutParams());
      if (animationBean != null) {
        Animator animator = WXAnimationModule.createAnimator(animationBean, component.getRealView());
        if (animator != null) {
          Animator.AnimatorListener animatorListener = WXAnimationModule.createAnimatorListener(mWXSDKInstance, callBack);
          Interpolator interpolator = WXAnimationModule.createTimeInterpolator(animationBean);
          if (animatorListener != null) {
            animator.addListener(animatorListener);
          }
          if (interpolator != null) {
            animator.setInterpolator(interpolator);
          }
          animator.setDuration(animationBean.duration);
          animator.start();
        }
      }
    } catch (RuntimeException e) {
      WXLogUtils.e(WXLogUtils.getStackTrace(e));
    }
  }
}
 

private void runAnimation(final ViewGroup container, final View from, final View to,
                          Flow.Direction direction, final Flow.TraversalCallback callback) {
    Animator animator = createSegue(from, to, direction);
    animator.addListener(new AnimatorListenerAdapter() {
        @Override
        public void onAnimationEnd(Animator animation) {
            container.removeView(from);
            callback.onTraversalCompleted();
        }
    });
    animator.start();
}
 

public static void createCircularRevealInverse(final View view,
                                                   int cx,
                                                   int cy,
                                                   int initialRadius,
                                                   final boolean setAsGone){
        if (Build.VERSION.SDK_INT < 21){
            if (setAsGone)
                animateSetViewVisibilityGone(view);
            else
                view.setVisibility(View.INVISIBLE);
        }else{
            view.setVisibility(View.VISIBLE);
            if (Build.VERSION.SDK_INT >= 12) {
                view.setScaleY(1);
                view.setScaleX(1);
            }

            try {
// create the animation (the final radius is zero)
                Animator anim =
                        ViewAnimationUtils.createCircularReveal(view, cx, cy, initialRadius, 0);

// make the view invisible when the animation is done
                anim.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        super.onAnimationEnd(animation);
                        view.setVisibility(setAsGone ? View.GONE : View.INVISIBLE);
                    }
                });

// start the animation
                anim.start();
            }catch (IllegalStateException ex) {
                ex.printStackTrace();
                view.setVisibility(setAsGone ? View.GONE : View.INVISIBLE);
            }
        }
    }
 

private void startSelectedViewInAnimation() {
    Animator animator = mSelectionInAnimator;
    animator.setTarget(mSelectorHolder.itemView);
    animator.addListener(new AbstractAnimatorListener() {
        @Override
        public void onAnimationEnd(Animator animation) {
            super.onAnimationEnd(animation);
            updateCategoriesOffsetBySelector();
        }
    });
    animator.start();
}
 

public void showFlipOnVertical(View v) {
    switch (v.getId()) {
        case R.id.iv_policebox:
        case R.id.iv_policeboxlight:
            if (mTestSwitch) {
                ObjectAnimator objectAnimator3 = ObjectAnimator.ofFloat(mShowAnimIV, "alpha", 1.0f, 0.25f, 0.75f, 0.15f, 0.5f, 0.0f);
                objectAnimator3.setDuration(C.Int.ANIM_DURATION * 10);
                objectAnimator3.setInterpolator(new LinearInterpolator());
                objectAnimator3.start();
            } else {
                ObjectAnimator objectAnimator3_1 = ObjectAnimator.ofFloat(mPoliceBoxIV, "alpha", 1.0f, 1.0f, 0.25f, 0.75f, 0.15f, 0.5f, 0.0f);
                ObjectAnimator objectAnimator3_2 = ObjectAnimator.ofFloat(mPoliceBoxLightIV, "alpha", 0.0f, 1.0f, 0.0f, 0.75f, 0.0f, 0.5f, 0.0f);
                AnimatorSet animatorSet3 = new AnimatorSet();
                animatorSet3.playTogether(
                        objectAnimator3_1,
                        objectAnimator3_2
                );
                animatorSet3.setDuration(C.Int.ANIM_DURATION * 5);
                animatorSet3.setInterpolator(new LinearInterpolator());
                animatorSet3.start();
            }
            mTestSwitch = !mTestSwitch;
            break;
        case R.id.btn_filponvertical:
            if (mTestSwitch) {
                Animator animator4 = AnimatorInflater.loadAnimator(this, R.animator.sda_flip_on_vertical);
                animator4.setTarget(mShowAnimIV);
                animator4.start();
            } else {
                ObjectAnimator objectAnimator4 = ObjectAnimator.ofFloat(mShowAnimIV, "rotationY", 0.0f, 360.0f);
                objectAnimator4.setDuration(C.Int.ANIM_DURATION);
                objectAnimator4.start();
            }
            mTestSwitch = !mTestSwitch;
            break;
    }
}
 

public void btnXML(final View view){
    Animator animator = AnimatorInflater.loadAnimator(this, R.animator.scalex);
    animator.setTarget(view);
    animator.start();
}
 

public void showAnimation(final View cardContainer, final View v, final int drawableId) {

        final View mRevealView = v;
        mRevealView.setBackgroundResource(drawableId);

        if (mCurrentDrawable == drawableId) {
            return;
        }

        int duration = 1000;
        int cx = mRevealView.getLeft();
        int cy = mRevealView.getTop();

        int radius = Math.max(mRevealView.getWidth(), mRevealView.getHeight()) * 4;

        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {


            SupportAnimator animator =
                    ViewAnimationUtils.createCircularReveal(mRevealView, cx, cy, 0, radius);
            animator.setInterpolator(new AccelerateDecelerateInterpolator());
            animator.setDuration(duration);

            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    cardContainer.setBackgroundResource(drawableId);
                }
            }, duration);

            mRevealView.setVisibility(View.VISIBLE);
            animator.start();
            mCurrentDrawable = drawableId;

        } else {
            Animator anim = android.view.ViewAnimationUtils.createCircularReveal(mRevealView, cx, cy, 0, radius);
            mRevealView.setVisibility(View.VISIBLE);
            anim.setDuration(duration);
            anim.start();
            anim.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    super.onAnimationEnd(animation);

                    cardContainer.setBackgroundResource(drawableId);
                }
            });

            mCurrentDrawable = drawableId;
        }
    }
 

private void openEditor(CustomAnimationBody animationBody) {

        final EditorFragment editorFragment = new EditorFragment();
        final FragmentManager fragmentManager = getSupportFragmentManager();

        editorFragment.setAnimationBody(animationBody);

        final FragmentTransaction transaction =
                fragmentManager.beginTransaction()
                        .replace(R.id.editorPanelContainer, editorFragment, EditorFragment.TAG);

        binding.mainPanelContainer.setVisibility(View.INVISIBLE);

        final Animator showAnimation = getShowWithReveal(binding.editorPanelContainer);

        Flubber.with()
                .animation(FABRevealProvider.create(R.drawable.ic_done_white_24dp))
                .duration(DURATION_REVEAL)
                .autoStart(true)
                .createFor(binding.floatingActionButton);

        showAnimation.start();

        transaction.commitNow();

        binding.setEditorOpen(true);
    }