コード例 #1
0
 /**
  * Sets up the animation supplied in the {@link AnimatorSet#play(Animator)} call that created
  * this <code>Builder</code> object to play when the given amount of time elapses.
  *
  * @param delay The number of milliseconds that should elapse before the animation starts.
  */
 public Builder after(long delay) {
   // setup dummy ValueAnimator just to run the clock
   ValueAnimator anim = ValueAnimator.ofFloat(0f, 1f);
   anim.setDuration(delay);
   after(anim);
   return this;
 }
コード例 #2
0
    public MyAnimationView(Context context) {
      super(context);

      // Animate background color
      // Note that setting the background color will automatically invalidate the
      // view, so that the animated color, and the bouncing balls, get redisplayed on
      // every frame of the animation.
      ValueAnimator colorAnim = ObjectAnimator.ofInt(this, "backgroundColor", RED, BLUE);
      colorAnim.setDuration(3000);
      colorAnim.setEvaluator(new ArgbEvaluator());
      colorAnim.setRepeatCount(ValueAnimator.INFINITE);
      colorAnim.setRepeatMode(ValueAnimator.REVERSE);
      colorAnim.start();
    }
コード例 #3
0
    @Override
    public boolean onTouchEvent(MotionEvent event) {
      if (event.getAction() != MotionEvent.ACTION_DOWN
          && event.getAction() != MotionEvent.ACTION_MOVE) {
        return false;
      }
      ShapeHolder newBall = addBall(event.getX(), event.getY());

      // Bouncing animation with squash and stretch
      float startY = newBall.getY();
      float endY = getHeight() - 50f;
      float h = (float) getHeight();
      float eventY = event.getY();
      int duration = (int) (500 * ((h - eventY) / h));
      ValueAnimator bounceAnim = ObjectAnimator.ofFloat(newBall, "y", startY, endY);
      bounceAnim.setDuration(duration);
      bounceAnim.setInterpolator(new AccelerateInterpolator());
      ValueAnimator squashAnim1 =
          ObjectAnimator.ofFloat(newBall, "x", newBall.getX(), newBall.getX() - 25f);
      squashAnim1.setDuration(duration / 4);
      squashAnim1.setRepeatCount(1);
      squashAnim1.setRepeatMode(ValueAnimator.REVERSE);
      squashAnim1.setInterpolator(new DecelerateInterpolator());
      ValueAnimator squashAnim2 =
          ObjectAnimator.ofFloat(newBall, "width", newBall.getWidth(), newBall.getWidth() + 50);
      squashAnim2.setDuration(duration / 4);
      squashAnim2.setRepeatCount(1);
      squashAnim2.setRepeatMode(ValueAnimator.REVERSE);
      squashAnim2.setInterpolator(new DecelerateInterpolator());
      ValueAnimator stretchAnim1 = ObjectAnimator.ofFloat(newBall, "y", endY, endY + 25f);
      stretchAnim1.setDuration(duration / 4);
      stretchAnim1.setRepeatCount(1);
      stretchAnim1.setInterpolator(new DecelerateInterpolator());
      stretchAnim1.setRepeatMode(ValueAnimator.REVERSE);
      ValueAnimator stretchAnim2 =
          ObjectAnimator.ofFloat(newBall, "height", newBall.getHeight(), newBall.getHeight() - 25);
      stretchAnim2.setDuration(duration / 4);
      stretchAnim2.setRepeatCount(1);
      stretchAnim2.setInterpolator(new DecelerateInterpolator());
      stretchAnim2.setRepeatMode(ValueAnimator.REVERSE);
      ValueAnimator bounceBackAnim = ObjectAnimator.ofFloat(newBall, "y", endY, startY);
      bounceBackAnim.setDuration(duration);
      bounceBackAnim.setInterpolator(new DecelerateInterpolator());
      // Sequence the down/squash&stretch/up animations
      AnimatorSet bouncer = new AnimatorSet();
      bouncer.play(bounceAnim).before(squashAnim1);
      bouncer.play(squashAnim1).with(squashAnim2);
      bouncer.play(squashAnim1).with(stretchAnim1);
      bouncer.play(squashAnim1).with(stretchAnim2);
      bouncer.play(bounceBackAnim).after(stretchAnim2);

      // Fading animation - remove the ball when the animation is done
      ValueAnimator fadeAnim = ObjectAnimator.ofFloat(newBall, "alpha", 1f, 0f);
      fadeAnim.setDuration(250);
      fadeAnim.addListener(
          new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
              balls.remove(((ObjectAnimator) animation).getTarget());
            }
          });

      // Sequence the two animations to play one after the other
      AnimatorSet animatorSet = new AnimatorSet();
      animatorSet.play(bouncer).before(fadeAnim);

      // Start the animation
      animatorSet.start();

      return true;
    }
コード例 #4
0
  private void startAnimation() {

    ValueAnimator mAnimatorAlpha = ValueAnimator.ofInt(255, 0);
    mAnimatorAlpha.addUpdateListener(
        new ValueAnimator.AnimatorUpdateListener() {
          @Override
          public void onAnimationUpdate(ValueAnimator animation) {
            int a = (int) animation.getAnimatedValue();
            Log.e("123132:", "" + a);
            mNewPaint.setAlpha((int) animation.getAnimatedValue());
            invalidate();
          }
        });
    mAnimatorAlpha.setDuration(2000);
    mAnimatorAlpha.start();

    //        Point startPoint = new Point(RADIUS, RADIUS);
    //        Point endPoint = new Point(getWidth() - RADIUS, getHeight() - RADIUS);
    //        ValueAnimator anim1 = ValueAnimator.ofObject(new PointEvaluator(), startPoint,
    // endPoint);
    //
    //        anim = ValueAnimator.ofObject(new ColorEvaluator(),
    //                "#FF0000", "#0000FF" );
    //        anim2 = ValueAnimator.ofObject( new ColorEvaluator(),
    //                "#0000FF", "#FF0000");
    //        AnimatorSet animSet = new AnimatorSet();
    //        animSet.play(anim1).with(anim2);
    //        animSet.setDuration(5000);
    //        anim1.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    //            @Override
    //            public void onAnimationUpdate(ValueAnimator animation) {
    //                currentPoint = (Point) animation.getAnimatedValue();
    //                invalidate();
    //            }
    //        });
    //
    //        anim2.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    //            @Override
    //            public void onAnimationUpdate(ValueAnimator animation) {
    //                mNewPaint.setColor(Color.parseColor((String) animation.getAnimatedValue()));
    //                invalidate();
    //            }
    //        });
    //        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
    //            @Override
    //            public void onAnimationUpdate(ValueAnimator animation) {
    //                mNewPaint.setColor(Color.parseColor((String) animation.getAnimatedValue()));
    //                invalidate();
    //            }
    //        });
    //
    //        anim.addListener(new Animator.AnimatorListener() {
    //            @Override
    //            public void onAnimationStart(Animator animation) {
    //
    //            }
    //
    //            @Override
    //            public void onAnimationEnd(Animator animation) {
    //                    isTrue = true;
    //            }
    //
    //            @Override
    //            public void onAnimationCancel(Animator animation) {
    //
    //            }
    //
    //            @Override
    //            public void onAnimationRepeat(Animator animation) {
    //
    //            }
    //        });
    //        anim2.addListener(new Animator.AnimatorListener() {
    //            @Override
    //            public void onAnimationStart(Animator animation) {
    //
    //            }
    //
    //            @Override
    //            public void onAnimationEnd(Animator animation) {
    //                anim.setDuration(5000);
    //                    anim.start();
    //            }
    //
    //            @Override
    //            public void onAnimationCancel(Animator animation) {
    //
    //            }
    //
    //            @Override
    //            public void onAnimationRepeat(Animator animation) {
    //
    //            }
    //        });
    //
    //        anim2.start();
  }
コード例 #5
0
ファイル: ObjectAnimator.java プロジェクト: HKhademian/Mover
 /**
  * Sets the length of the animation. The default duration is 300 milliseconds.
  *
  * @param duration The length of the animation, in milliseconds.
  * @return ObjectAnimator The object called with setDuration(). This return value makes it easier
  *     to compose statements together that construct and then set the duration, as in <code>
  *     ObjectAnimator.ofInt(target, propertyName, 0, 10).setDuration(500).start()</code>.
  */
 @Override
 public ObjectAnimator setDuration(long duration) {
   super.setDuration(duration);
   return this;
 }
コード例 #6
0
  /**
   * {@inheritDoc}
   *
   * <p>Starting this <code>AnimatorSet</code> will, in turn, start the animations for which it is
   * responsible. The details of when exactly those animations are started depends on the dependency
   * relationships that have been set up between the animations.
   */
  @SuppressWarnings("unchecked")
  @Override
  public void start() {
    mTerminated = false;
    mStarted = true;

    // First, sort the nodes (if necessary). This will ensure that sortedNodes
    // contains the animation nodes in the correct order.
    sortNodes();

    int numSortedNodes = mSortedNodes.size();
    for (int i = 0; i < numSortedNodes; ++i) {
      Node node = mSortedNodes.get(i);
      // First, clear out the old listeners
      ArrayList<AnimatorListener> oldListeners = node.animation.getListeners();
      if (oldListeners != null && oldListeners.size() > 0) {
        final ArrayList<AnimatorListener> clonedListeners =
            new ArrayList<AnimatorListener>(oldListeners);

        for (AnimatorListener listener : clonedListeners) {
          if (listener instanceof DependencyListener || listener instanceof AnimatorSetListener) {
            node.animation.removeListener(listener);
          }
        }
      }
    }

    // nodesToStart holds the list of nodes to be started immediately. We don't want to
    // start the animations in the loop directly because we first need to set up
    // dependencies on all of the nodes. For example, we don't want to start an animation
    // when some other animation also wants to start when the first animation begins.
    final ArrayList<Node> nodesToStart = new ArrayList<Node>();
    for (int i = 0; i < numSortedNodes; ++i) {
      Node node = mSortedNodes.get(i);
      if (mSetListener == null) {
        mSetListener = new AnimatorSetListener(this);
      }
      if (node.dependencies == null || node.dependencies.size() == 0) {
        nodesToStart.add(node);
      } else {
        int numDependencies = node.dependencies.size();
        for (int j = 0; j < numDependencies; ++j) {
          Dependency dependency = node.dependencies.get(j);
          dependency.node.animation.addListener(
              new DependencyListener(this, node, dependency.rule));
        }
        node.tmpDependencies = (ArrayList<Dependency>) node.dependencies.clone();
      }
      node.animation.addListener(mSetListener);
    }
    // Now that all dependencies are set up, start the animations that should be started.
    if (mStartDelay <= 0) {
      for (Node node : nodesToStart) {
        node.animation.start();
        mPlayingSet.add(node.animation);
      }
    } else {
      mDelayAnim = ValueAnimator.ofFloat(0f, 1f);
      mDelayAnim.setDuration(mStartDelay);
      mDelayAnim.addListener(
          new AnimatorListenerAdapter() {
            boolean canceled = false;

            @Override
            public void onAnimationCancel(Animator anim) {
              canceled = true;
            }

            @Override
            public void onAnimationEnd(Animator anim) {
              if (!canceled) {
                int numNodes = nodesToStart.size();
                for (int i = 0; i < numNodes; ++i) {
                  Node node = nodesToStart.get(i);
                  node.animation.start();
                  mPlayingSet.add(node.animation);
                }
              }
            }
          });
      mDelayAnim.start();
    }
    if (mListeners != null) {
      ArrayList<AnimatorListener> tmpListeners = (ArrayList<AnimatorListener>) mListeners.clone();
      int numListeners = tmpListeners.size();
      for (int i = 0; i < numListeners; ++i) {
        tmpListeners.get(i).onAnimationStart(this);
      }
    }
    if (mNodes.size() == 0 && mStartDelay == 0) {
      // Handle unusual case where empty AnimatorSet is started - should send out
      // end event immediately since the event will not be sent out at all otherwise
      mStarted = false;
      if (mListeners != null) {
        ArrayList<AnimatorListener> tmpListeners = (ArrayList<AnimatorListener>) mListeners.clone();
        int numListeners = tmpListeners.size();
        for (int i = 0; i < numListeners; ++i) {
          tmpListeners.get(i).onAnimationEnd(this);
        }
      }
    }
  }